C++ 使用Socket实现主机间的UDP/TCP通信

博主：六月丶
发布时间：2022 年 12 月 31 日
1411 次浏览
1 条评论
4118字数
分类：技术

前言

完整代码放到github上了：cppSocketDemo

服务器端的代码做了跨平台（POSIX和WINDOWS），基于POSIX平台（Linux、Mac OS X、PlayStation等）使用sys/socket.h库，windows平台使用winsock2.h库。
客户端代码因为基本都在windows运行，所以没做跨平台，需要的话你可以参考服务器端代码自己做一下。
文中写的函数原型均为windows平台，部分函数的返回类型或参数类型在POSIX会有不同。

头文件

根据_WIN32标志区分,导入头文件。

#include<iostream>
#include<cstring>
#ifdef _WIN32

#include<winsock2.h>

#else

#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
typedef int SOCKET;

#endif

因为POSIX平台的socket库没有SOCKET类型，所以我们手动定义一下。

UDP Socket

服务器端

对于windows，使用socket前需要手动开启：

#ifdef _WIN32
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &wsd)){
        std::cout << "WSAStartup Error" << std::endl;
        exit(-1);
    }   
#endif

WSAStartup第一个参数表示使用版本号。该函数会向第二个参数填入被激活的socket库的信息。

SOCKET函数

SOCKET socket(int af, int type, int protocol);

参数：

af:socket使用协议族，如AF_INET表示IPv4, AF_INET6表示IPv6等。

type:指明通过socket发送和接收分组的形式。如SOCK_STREAM表示有序、可靠的数据流分段；SOCK_DGRAM表示离散的报文；SOCK_RAW表示数据头部可以由应用层自定义。

protocol：指明发送数据使用什么协议。IPPROTO_UDP；IPPROTO_TCP;IPPROTO_IP;0表示根据socket类型选择默认协议。

通过socket函数创建并返回一个udp类型socket对象：

SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, 0);

bind函数

将一个socket绑定到一个地址和端口号，使用bind函数：
int bind(SOCKET sock, const sockaddr *address, int address_len);
参数：

sock: 绑定socket

address：注意是指发送数据包的源地址，而不是发送目的地址

address_len：存储address的sockaddr结构体大小
bind成功时返回0，出现错误时返回-1
给端口号赋值0，将告诉socket库找一个未被使用的端口并绑定
如果一个进程试图使用一个未绑定的socket发送数据，网络库将自动为这个socket绑定一个可用的端口号。
所以对于服务器来说手动调用bind绑定是必须的，而对于客户端来说通常是没有必要的。

服务器端socket需要显式绑定地址和端口，以便客户端访问：

sockaddr_in sain;
sain.sin_family = AF_INET;    //使用IPv4
sain.sin_addr.s_addr = htonl(INADDR_ANY);
sain.sin_port = htons(atoi("50002"));

if(bind(udpSocket, (sockaddr *)&sain, sizeof(sockaddr)) == -1){
    std::cout << "绑定失败" << std::endl;
}

recvfrom函数

从UDP Socket接收数据
int recvfrom(SOCKET s,char buf,int len,int flags,struct sockaddr from,int *fromlen);
参数：

s: 查询数据的socket。默认情况下，

buf：接收的数据包的缓冲区。

len: buf可以存储的最大字节数。到达的数据包的剩余字节将被丢弃。

flags: 同sendto flags。

from: 指向发送者的地址和端口号的指针，该值由recvfrom函数写入（每接收一个数据包写入一次）。不要手动填写。

fromlen: from所指向sockaddr的大小
如果recvfrom成功执行会返回复制到buf的字节数，发生错误返回-1。

服务器通过recvfrom函数接收客户端信息:

const size_t BufMaxSize = 1000;
char buf[BufMaxSize] = {}; 
sockaddr fromAddr;
#ifndef _WIN32
unsigned
#endif
int fromAddrLen = sizeof(sockaddr);
std::cout << "等待接收..." << std::endl;
while(true){
    if(recvfrom(udpSocket, buf, BufMaxSize, 0, &fromAddr, &fromAddrLen) != -1){
        std::cout << "接收到数据：" << buf << std::endl;
        memset(buf, 0, sizeof(buf));
    }   
    else{
        std::cout << "接收失败或发生错误！" << std::endl;
        return -1; 
    }   
}

最后记得做关闭工作

#ifdef _WIN32
    WSACleanup();
    closesocket(udpSocket);
#else
    close(udpSocket);
#endif

udpServer.cpp 完整代码

#include<iostream>
#include<cstring>
#ifdef _WIN32

#include<winsock2.h>

#else

#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
typedef int SOCKET;

#endif

int main(){
#ifdef _WIN32
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &wsd)){
        std::cout << "WSAStartup Error" << std::endl;
        exit(-1);
    }   
#endif
    SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, 0); 
    sockaddr_in sain;
    sain.sin_family = AF_INET;
    sain.sin_addr.s_addr = htonl(INADDR_ANY);
    sain.sin_port = htons(atoi("50002"));

    if(bind(udpSocket, (sockaddr *)&sain, sizeof(sockaddr)) == -1){
        std::cout << "绑定失败" << std::endl;
    }   
    const size_t BufMaxSize = 1000;
    char buf[BufMaxSize] = {}; 
    sockaddr fromAddr;
#ifndef _WIN32
    unsigned
#endif
    int fromAddrLen = sizeof(sockaddr);
    std::cout << "等待接收..." << std::endl;
    while(true){
        if(recvfrom(udpSocket, buf, BufMaxSize, 0, &fromAddr, &fromAddrLen) != -1){
            std::cout << "接收到数据：" << buf << std::endl;
            memset(buf, 0, sizeof(buf));
        }   
        else{
            std::cout << "接收失败或发生错误！" << std::endl;
            return -1; 
        }   
    }   
    //shutdown(udpSocket, SB_BOTH);
#ifdef _WIN32
    WSACleanup();
    closesocket(udpSocket);
#else
    close(udpSocket);
#endif

    return 0;
}

客户端

和服务器一样的先激活:

WSADATA wsd;
if(WSAStartup(MAKEWORD(2, 2), &wsd)){
    std::cout << "WSAStartup Error" << std::endl;
    exit(-1);
}

创建socket：

SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, 0);

将目标远程主机的IP和端口信息填入sockaddr：

先写一个工具函数:

sockaddr GetSockAddr(uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint16_t inPort){
    sockaddr addr;
    sockaddr_in *addrin = reinterpret_cast<sockaddr_in*>(&addr);
    addrin->sin_family = AF_INET;
    addrin->sin_addr.S_un.S_un_b.s_b1 = b1;
    addrin->sin_addr.S_un.S_un_b.s_b2 = b2;
    addrin->sin_addr.S_un.S_un_b.s_b3 = b3;
    addrin->sin_addr.S_un.S_un_b.s_b4 = b4;
    addrin->sin_port = htons(inPort);

    return addr;
}

sockaddr toAddr = GetSockAddr(127, 0, 0, 1, 50002);

sendTo函数

从UDP Socket发送数据
int sendto(SOCKET s,const char buf,int len,int flags,const struct sockaddr to,int tolen);
参数：

s: 数据包应该使用的socket，如果没有绑定，socket库将自动绑定一个可用的端口。

buf: 待发送数据的起始地址的指针。可以是任何能够被转为char*的数据类型。

len: 待发送数据的大小。尽量避免发送数据大于1300字节的数据包，详见p75。

flags: 对控制发送的标志进行按位或运算的结果，该值通常取0即可。

to: 目标接收者的sockaddr。注意to的地址族必须和用于创建socket的地址族一致。

tolen:to的sockaddr的大小。对于IPv4,传入sizeof(sockaddr_in)即可。
sendto操作成功返回等待发送的数据长度（说明成功进入发送队列），否则返回-1。

通过senTo函数发送数据：

const size_t BufMaxSize = 1000;
char buf[BufMaxSize] = {};
sockaddr toAddr = GetSockAddr(127, 0, 0, 1, 50002); 
int toAddrLen = sizeof(sockaddr);
std::cout << ">>> ";
while(true){
    if(std::cin >> buf){
        sendto(udpSocket, buf, strlen(buf), 0, &toAddr, toAddrLen);
        std::cout << "已发送!" <<std::endl;
        std::cout << ">>> ";
        memset(buf, 0, sizeof(buf));
    }
}

注意，这样发送给linux服务器带中文的字符串的话，可能出现乱码，因为linux通常为UTF-8编码，而windows通常为gb2312编码，所以我们可以在客户端实现两个编码转换函数，并在恰当时机转换：

//UTF-8转GB2312
char* U2G(const char* utf8){
    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    wchar_t* wstr = new wchar_t[len+1];
    memset(wstr, 0, len+1);
    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
    len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* str = new char[len+1];
    memset(str, 0, len+1);
    WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
    if(wstr) delete[] wstr;
    return str;
}
//GB2312转UTF-8
char* G2U(const char* gb2312){
    int len = MultiByteToWideChar(CP_ACP, 0, gb2312, -1, NULL, 0);
    wchar_t* wstr = new wchar_t[len+1];
    memset(wstr, 0, len+1);
    MultiByteToWideChar(CP_ACP, 0, gb2312, -1, wstr, len);
    len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* str = new char[len+1];
    memset(str, 0, len+1);
    WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
    if(wstr) delete[] wstr;
    return str;
}

发送改为:

char *buf_UTF8 = G2U(buf);
sendto(udpSocket, buf_UTF8, strlen(buf_UTF8), 0, &toAddr, toAddrLen);

最后同样的关闭操作:

closesocket(udpSocket);
WSACleanup();

udpClient.cpp 完整代码

#include<iostream>
#include<Winsock2.h>
#include<windows.h>

//UTF-8转GB2312
char* U2G(const char* utf8){
    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    wchar_t* wstr = new wchar_t[len+1];
    memset(wstr, 0, len+1);
    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
    len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* str = new char[len+1];
    memset(str, 0, len+1);
    WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
    if(wstr) delete[] wstr;
    return str;
}
//GB2312转UTF-8
char* G2U(const char* gb2312){
    int len = MultiByteToWideChar(CP_ACP, 0, gb2312, -1, NULL, 0);
    wchar_t* wstr = new wchar_t[len+1];
    memset(wstr, 0, len+1);
    MultiByteToWideChar(CP_ACP, 0, gb2312, -1, wstr, len);
    len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* str = new char[len+1];
    memset(str, 0, len+1);
    WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
    if(wstr) delete[] wstr;
    return str;
}

sockaddr GetSockAddr(uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint16_t inPort){
    sockaddr addr;
    sockaddr_in *addrin = reinterpret_cast<sockaddr_in*>(&addr);
    addrin->sin_family = AF_INET;
    addrin->sin_addr.S_un.S_un_b.s_b1 = b1;
    addrin->sin_addr.S_un.S_un_b.s_b2 = b2;
    addrin->sin_addr.S_un.S_un_b.s_b3 = b3;
    addrin->sin_addr.S_un.S_un_b.s_b4 = b4;
    addrin->sin_port = htons(inPort);

    return addr;
}

int main(){
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &wsd)){
        std::cout << "WSAStartup Error" << std::endl;
        exit(-1);
    }

    SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, 0);
    const size_t BufMaxSize = 1000;
    char buf[BufMaxSize] = {};
        sockaddr toAddr = GetSockAddr(127, 0, 0, 1, 50002); 
    int toAddrLen = sizeof(sockaddr);
    std::cout << ">>> ";
    while(true){
        if(std::cin >> buf){
            char *buf_UTF8 = G2U(buf);
            sendto(udpSocket, buf_UTF8, strlen(buf_UTF8), 0, &toAddr, toAddrLen);
            std::cout << "已发送!" <<std::endl;
            std::cout << ">>> ";
            memset(buf, 0, sizeof(buf));
        }
    }

    //shutdown(udpSocket, SB_BOTH);
    closesocket(udpSocket);

    WSACleanup();

    return 0;
}

测试

注意，如果把服务器代码放到windows下执行，记得把客户端的转编码代码改下。

注意，编译使用C++11以上编译，链接时加入库:

-lwsock32

将udpServer.cpp放到服务器上,服务器防火墙记得放行目标端口或暂时关闭防火墙。
udpClient.cpp在本地（windows）。
udpClient中的目标远程主机地址改为服务器ip地址,编译运行：

服务器:

客户端：

TCP Socket（单客户端连接）

服务器

同样先激活winsock：

#ifdef _WIN32
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &wsd)){
        std::cout << "WSAStartup Error" << std::endl;
        return -1;
    }
#endif

创建tcp类型socket：

SOCKET tcpsocket = socket(AF_INET, SOCK_STREAM, 0);

绑定本机地址和指定端口号:

sockaddr_in sain;
sain.sin_family = AF_INET;
sain.sin_addr.s_addr = htonl(INADDR_ANY);
sain.sin_port = htons(atoi("50002"));
if(bind(tcpsocket, (sockaddr*)&sain, sizeof(sockaddr)) == -1){
    std::cout << "bind Error" <<  std::endl;
    return -1;
}

listen函数

用listen函数启动监听，等待客户端的连接：
int listen(SOCKET sock, int backlog);
backlog指队列允许传入的最大连接数，超过最大值的连接都将被丢弃。可以使用SOMAXCONN表示默认的backlog值。
函数执行成功返回0，失败返回-1。

使用listen函数开启监听：

listen(tcpsocket, 10);

主机针对每个保持的TCP连接，都需要一个独立的socket存储连接状态。
这里先做只能连接单个客户端，创建连接客户端的socket：

sockaddr clientAddr;        //

#ifndef _WIN32
    unsigned
#endif
    int clientAddrLen = sizeof(sockaddr);

accept函数

接受传入的连接并继续TCP握手过程，调用accept函数：
SOCKET accept(SOCKET sock, sockaddr addr, int addrlen);
参数:
sock: 接收传入连接的监听socket
addr: 将被写入请求连接的远程主机地址。同样不要手动填写
addrlen: 指向addr缓冲区大小的指针。当真正写入地址之后，accept会更新该值。
如果accept执行成功，将创建并返回一个可以与远程主机通信的新socket。

接受传入的连接并继续TCP握手过程：

SOCKET linkSocket = accept(tcpsocket, &clientAddr, &clientAddrLen);

recv函数

调用recv函数从一个连接的TCP socket接收数据：
int recv(SOCKET s,char *buf,int len,int flags);
参数：
s: 待接收数据的socket
buf: 数据接收缓冲区。
len: 拷贝到buf中的数据的最大数量。
flags: 标志位，大多数情况填0。
调用成功返回接收的数据大小。如果返回0，说明连接的另一端发送了一个FIN数据包，承诺没有更多需要发送的数据。
如果发生错误，返回-1
默认情况下，如果socket的接收缓冲区中没有数据，recv函数将阻塞调用线程，直到数据流中的下一组数据到达或超时。

send函数

通过连接的socket使用send函数发送数据：
因为连接的socket存储了远程主机地址信息，所以不需要传入地址参数：
int send(SOCKET s,const char *buf,int len,int flags);
参数：
s: 用于发送数据的socket
buf: 写入缓冲区。注意：和UDP不同，是将数据放到socket的输出缓冲区中，由socket库来决定在将来某一时刻发出。
len: 传输的字节数量。注意：与UDP不同，不需要保持这个值低于链路层的MTU。
flags:标志位，大多数情况下填0即可。
send调用成功返回发送数据的大小，如果发送错误返回-1.
默认情况下该函数会阻塞线程，直到调用超时或发送了足够的数据。
非0的返回值不代表成功发送出去了，只说明数据被存入队列中等待发送。

使用recv函数和send函数接收和响应客户端信息:

const size_t BufMaxLen = 1000;
char buf[BufMaxLen] = {};
char sendBuf[BufMaxLen] = "服务器成功接收!";
while(true){
    int ret = recv(linkSocket, buf, BufMaxLen, 0);
    if(ret > 0){
        std::cout << "从客户端接收到数据:" << buf << std::endl;
        memset(buf, 0, BufMaxLen);
        send(linkSocket, sendBuf, strlen(sendBuf), 0);
    }
    else if(ret == 0){
        std::cout << "客户端停止发送数据，准备关闭连接..." << std::endl;
        break;
    }
    else{
        std::cout << "recv发生错误！" << std::endl;
    }
}

最后关闭:

#ifdef _WIN32
    closesocket(tcpsocket);
    closesocket(linkSocket);
    WSACleanup();
#else
    close(tcpsocket);
    close(linkSocket);
#endif
    std::cout << "已关闭服务器Socket..." << std::endl;

tcpServer.cpp 完整代码

#include<iostream>
#include<cstring>
#ifdef _WIN32

#include<winsock2.h>

#else

#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
typedef int SOCKET;

#endif

int main(){
#ifdef _WIN32
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &wsd)){
        std::cout << "WSAStartup Error" << std::endl;
        return -1;
    }
#endif
    SOCKET tcpsocket = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in sain;
    sain.sin_family = AF_INET;
    sain.sin_addr.s_addr = htonl(INADDR_ANY);
    sain.sin_port = htons(atoi("50002"));
    if(bind(tcpsocket, (sockaddr*)&sain, sizeof(sockaddr)) == -1){
        std::cout << "bind Error" <<  std::endl;
        return -1;
    }
    listen(tcpsocket, 10);
    std::cout << "等待连接中..." << std::endl;
    sockaddr clientAddr;        //

#ifndef _WIN32
    unsigned
#endif
    int clientAddrLen = sizeof(sockaddr);
    SOCKET linkSocket = accept(tcpsocket, &clientAddr, &clientAddrLen);
    std::cout << "连接成功！" << std::endl;
    const size_t BufMaxLen = 1000;
    char buf[BufMaxLen] = {};
    char sendBuf[BufMaxLen] = "服务器成功接收!";
    while(true){
        int ret = recv(linkSocket, buf, BufMaxLen, 0);
        if(ret > 0){
            std::cout << "从客户端接收到数据:" << buf << std::endl;
            memset(buf, 0, BufMaxLen);
            send(linkSocket, sendBuf, strlen(sendBuf), 0);
        }
        else if(ret == 0){
            std::cout << "客户端停止发送数据，准备关闭连接..." << std::endl;
            break;
        }
        else{
            std::cout << "recv发生错误！" << std::endl;

        }
    }

#ifdef _WIN32
    closesocket(tcpsocket);
    closesocket(linkSocket);
    WSACleanup();
#else
    close(tcpsocket);
    close(linkSocket);
#endif
    std::cout << "已关闭服务器Socket..." << std::endl;

    return 0;
}

客户端

客户端没有新函数，直接看代码吧！

tcpClient.cpp 完整代码

#include<iostream>
#include<winsock2.h>
#include<windows.h>
#include<memory>
#include<cstring>

using namespace std;

//UTF-8转GB2312
char* U2G(const char* utf8){
    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    wchar_t* wstr = new wchar_t[len+1];
    memset(wstr, 0, len+1);
    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
    len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* str = new char[len+1];
    memset(str, 0, len+1);
    WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
    if(wstr) delete[] wstr;
    return str;
}
//GB2312转UTF-8
char* G2U(const char* gb2312){
    int len = MultiByteToWideChar(CP_ACP, 0, gb2312, -1, NULL, 0);
    wchar_t* wstr = new wchar_t[len+1];
    memset(wstr, 0, len+1);
    MultiByteToWideChar(CP_ACP, 0, gb2312, -1, wstr, len);
    len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* str = new char[len+1];
    memset(str, 0, len+1);
    WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
    if(wstr) delete[] wstr;
    return str;
}

sockaddr GetSockAddr(uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint16_t inPort){
    sockaddr addr;
    sockaddr_in *addrin = reinterpret_cast<sockaddr_in*>(&addr);
    addrin->sin_family = AF_INET;
    addrin->sin_addr.S_un.S_un_b.s_b1 = b1;
    addrin->sin_addr.S_un.S_un_b.s_b2 = b2;
    addrin->sin_addr.S_un.S_un_b.s_b3 = b3;
    addrin->sin_addr.S_un.S_un_b.s_b4 = b4;
    addrin->sin_port = htons(inPort);

    return addr;
}


int main(){
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &wsd)){
        std::cout << "WSAStartup Error" << std::endl;
        return -1;
    }
    SOCKET tcpSocket = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr serverAddr = GetSockAddr(127, 0, 0, 1, 50002);   
    int serverAddrLen = sizeof(sockaddr);
    if(connect(tcpSocket, &serverAddr, serverAddrLen) == -1){
        std::cout << "connect Error!" << std::endl;
        return -1;
    }
    std::cout << "已成功连接到服务器" << std::endl;
    //客户端的socket就是用于连接的socket
    const int BufMaxLen = 1000;
    char sendBuf[BufMaxLen] = {};
    char buf[BufMaxLen] = {};
    std::cout << ">>> ";
    while(true){
        if(std::cin >> sendBuf){
            if(strcmp(sendBuf, "exit") == 0){
                std::cout << "正在关闭连接..." << std::endl;
                break;
            }
            char *sendBuf_UTF8 = G2U(sendBuf);
            send(tcpSocket, sendBuf_UTF8, strlen(sendBuf_UTF8), 0);
            memset(sendBuf, 0, BufMaxLen);
            int ret = recv(tcpSocket, buf, BufMaxLen, 0);
            if(ret > 0){
                std::cout << "从服务器接收到回应：" << U2G(buf) << std::endl;
                memset(buf, 0, BufMaxLen);
            }
            std::cout << ">>> ";
        }
    }


    shutdown(tcpSocket, SB_BOTH);
    closesocket(tcpSocket);
    WSACleanup();
    std::cout << "已关闭客户端Socket..." << std::endl;

    return 0;
}

测试

注意，如果把服务器代码放到windows下执行，记得把客户端的转编码代码改下。

测试方式同上面UDP。

客户端：

服务器:

TCP Socket（多客户端连接）

服务端

使用多线程，每响应一个客户端连接为它创建一个线程。
多线程头文件：

#include<thread>

将之前的响应代码搬到函数中作为线程入口：

void linkClientThread(SOCKET linkSocket, unsigned int linkId){
    printf("客户端(id:%d) 已连接！\n", linkId);
    const size_t BufMaxLen = 1000;
    char buf[BufMaxLen] = {};
    char sendBuf[BufMaxLen] = "服务器成功接收!";
    while(true){
        int ret = recv(linkSocket, buf, BufMaxLen, 0);
        if(ret > 0){
            printf("从客户端(id:%d)接收到数据:%s\n", linkId, buf);
            memset(buf, 0, BufMaxLen);
            send(linkSocket, sendBuf, strlen(sendBuf), 0);
        }
        else if(ret == 0){
            printf("客户端(id:%d)停止发送数据，关闭连接...\n", linkId);
            break;
        }
        else{
            printf("recv发生错误！\n");
            break;
        }
    }

#ifdef _WIN32
    closesocket(linkSocket);
#else
    close(linkSocket);
#endif

}

当接收到连接请求，为它单独创建一个线程服务：

while(true){
    SOCKET linkSocket = accept(tcpsocket, &clientAddr, &clientAddrLen);
    std::thread linkThread(linkClientThread, linkSocket, ++linkId);
    linkThread.detach();
}

tcpServer_multiConnection.cpp 完整代码

#include<iostream>
#include<cstring>
#include<thread>
#include<vector>
#ifdef _WIN32

#include<winsock2.h>

#else

#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
typedef int SOCKET;

#endif

void linkClientThread(SOCKET linkSocket, unsigned int linkId){
    printf("客户端(id:%d) 已连接！\n", linkId);
    const size_t BufMaxLen = 1000;
    char buf[BufMaxLen] = {};
    char sendBuf[BufMaxLen] = "服务器成功接收!";
    while(true){
        int ret = recv(linkSocket, buf, BufMaxLen, 0);
        if(ret > 0){
            printf("从客户端(id:%d)接收到数据:%s\n", linkId, buf);
            memset(buf, 0, BufMaxLen);
            send(linkSocket, sendBuf, strlen(sendBuf), 0);
        }
        else if(ret == 0){
            printf("客户端(id:%d)停止发送数据，关闭连接...\n", linkId);
            break;
        }
        else{
            printf("recv发生错误！\n");
            break;
        }
    }

#ifdef _WIN32
    closesocket(linkSocket);
#else
    close(linkSocket);
#endif

}

int main(){
#ifdef _WIN32
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &wsd)){
        std::cout << "WSAStartup Error" << std::endl;
        return -1;
    }
#endif
    SOCKET tcpsocket = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in sain;
    sain.sin_family = AF_INET;
    sain.sin_addr.s_addr = htonl(INADDR_ANY);
    sain.sin_port = htons(atoi("50002"));
    if(bind(tcpsocket, (sockaddr*)&sain, sizeof(sockaddr)) == -1){
        std::cout << "bind Error" <<  std::endl;
        return -1;
    }
    listen(tcpsocket, 10);
    std::cout << "等待连接中..." << std::endl;

    unsigned int linkId = 0;
    sockaddr clientAddr;        //
#ifndef _WIN32
    unsigned
#endif
    int clientAddrLen = sizeof(sockaddr);
    while(true){
        SOCKET linkSocket = accept(tcpsocket, &clientAddr, &clientAddrLen);
        std::thread linkThread(linkClientThread, linkSocket, ++linkId);
        linkThread.detach();
    }


#ifdef _WIN32
    closesocket(tcpsocket);
    WSACleanup();
#else
    close(tcpsocket);
#endif
    std::cout << "已关闭服务器Socket..." << std::endl;


    return 0;
}

客户端

客户端直接继续使用之前的tcpClient.cpp即可，没有区别。

测试

同样的注意，如果把服务器代码放到windows下执行，记得把客户端的转编码代码改下。

服务器还是使用linux系统的，所有客户端在本地的windows执行：
注意：server代码在linux编译时要加入-lpthread.h选项:

g++ -g tcpServer_multiConnection.cpp -o tcpServer_multiConnection -std=c++11 -lpthread

客户端1:

客户端2：

服务器:

全部代码也可以在github上获取：cppSocketDemo

参考文献：《网络多人游戏架构与编程》

最后修改：2023 年 01 月 03 日

如果觉得我的文章对你有用，请随意赞赏

1 条评论

22攻略
May 23rd, 2023 at 06:46 pm

你写得非常清晰明了，让我很容易理解你的观点。

回复

发表评论取消回复

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

UE4常用蓝图Actions
浏览次数: 38775
学生管理系统
浏览次数: 6559
【python爬虫】爬取洛谷习题并转为md格式
浏览次数: 4863
[教程]字符动画制作
浏览次数: 4413
用代码实现解数独
浏览次数: 3813

勿忘初心
您好，看你的站做的挺不错的，有没有出手的打算，想出手的话，联系...
流量卡知识网
你好，看完你的博客文章，感觉很不错！希望与你网站首页友情链接流...
iiii520
向大佬学习
22攻略
你写得非常清晰明了，让我很容易理解你的观点。
00
我也在摆烂2333

C++ 使用Socket实现主机间的UDP/TCP通信

六月丶 • 2022 年 12 月 31 日

<h2>前言</h2>
<p>完整代码放到github上了：<span class="external-link"><a class="no-external-link" href="https://github.com/cout357/cppSocketDemo" target="_blank"><i data-feather="external-link"></i>cppSocketDemo</a></span></p>
<p>服务器端的代码做了跨平台（POSIX和WINDOWS），基于POSIX平台（Linux、Mac OS X、PlayStation等）使用sys/socket.h库，windows平台使用winsock2.h库。<br />
客户端代码因为基本都在windows运行，所以没做跨平台，需要的话你可以参考服务器端代码自己做一下。<br />
文中写的函数原型均为windows平台，部分函数的返回类型或参数类型在POSIX会有不同。</p>
<h2>头文件</h2>
<p>根据_WIN32标志区分,导入头文件。</p>
<pre><code>#include&lt;iostream&gt;
#include&lt;cstring&gt;
#ifdef _WIN32

#include&lt;winsock2.h&gt;

#else

#include &lt;sys/socket.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;sys/types.h&gt;
#include &lt;netdb.h&gt;
#include &lt;errno.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;unistd.h&gt;
typedef int SOCKET;

#endif</code></pre>
<p>因为POSIX平台的socket库没有SOCKET类型，所以我们手动定义一下。</p>
<h2>UDP Socket</h2>
<h3>服务器端</h3>
<p>对于windows，使用socket前需要手动开启：</p>
<pre><code>#ifdef _WIN32
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &amp;wsd)){
        std::cout &lt;&lt; "WSAStartup Error" &lt;&lt; std::endl;
        exit(-1);
    }   
#endif</code></pre>
<p>WSAStartup第一个参数表示使用版本号。该函数会向第二个参数填入被激活的socket库的信息。</p>
<p><strong>SOCKET函数</strong></p>
<blockquote>
<p>SOCKET socket(int af, int type, int protocol);</p>
<p>参数：</p>
<ul>
<li>af:socket使用协议族，如AF_INET表示IPv4, AF_INET6表示IPv6等。</li>
<li>type:指明通过socket发送和接收分组的形式。如SOCK_STREAM表示有序、可靠的数据流分段；SOCK_DGRAM表示离散的报文；SOCK_RAW表示数据头部可以由应用层自定义。</li>
<li>protocol：指明发送数据使用什么协议。IPPROTO_UDP；IPPROTO_TCP;IPPROTO_IP;0表示根据socket类型选择默认协议。</li>
</ul>
</blockquote>
<p>通过socket函数创建并返回一个udp类型socket对象：</p>
<pre><code>SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, 0);</code></pre>
<p><strong>bind函数</strong></p>
<blockquote>
<p>将一个socket绑定到一个地址和端口号，使用bind函数：<br />
int bind(SOCKET sock, const sockaddr *address, int address_len);<br />
参数：</p>
<ul>
<li>sock: 绑定socket</li>
<li>address：注意是指发送数据包的源地址，而不是发送目的地址</li>
<li>address_len：存储address的sockaddr结构体大小<br />
bind成功时返回0，出现错误时返回-1<br />
给端口号赋值0，将告诉socket库找一个未被使用的端口并绑定<br />
如果一个进程试图使用一个未绑定的socket发送数据，网络库将自动为这个socket绑定一个可用的端口号。<br />
所以对于服务器来说手动调用bind绑定是必须的，而对于客户端来说通常是没有必要的。</li>
</ul>
</blockquote>
<p>服务器端socket需要显式绑定地址和端口，以便客户端访问：</p>
<pre><code class="language-cpp">sockaddr_in sain;
sain.sin_family = AF_INET;    //使用IPv4
sain.sin_addr.s_addr = htonl(INADDR_ANY);
sain.sin_port = htons(atoi("50002"));

if(bind(udpSocket, (sockaddr *)&amp;sain, sizeof(sockaddr)) == -1){
    std::cout &lt;&lt; "绑定失败" &lt;&lt; std::endl;
}</code></pre>
<p><strong>recvfrom函数</strong></p>
<blockquote>
<p>从UDP Socket接收数据<br />
int recvfrom(SOCKET s,char <em>buf,int len,int flags,struct sockaddr </em>from,int *fromlen);<br />
参数：</p>
<ul>
<li>s:      查询数据的socket。默认情况下，</li>
<li>buf：        接收的数据包的缓冲区。</li>
<li>len:        buf可以存储的最大字节数。到达的数据包的剩余字节将被丢弃。</li>
<li>flags:  同sendto flags。</li>
<li>from:       指向发送者的地址和端口号的指针，该值由recvfrom函数写入（每接收一个数据包写入一次）。不要手动填写。</li>
<li>fromlen:    from所指向sockaddr的大小<br />
如果recvfrom成功执行会返回复制到buf的字节数，发生错误返回-1。</li>
</ul>
</blockquote>
<p>服务器通过recvfrom函数接收客户端信息:</p>
<pre><code>const size_t BufMaxSize = 1000;
char buf[BufMaxSize] = {}; 
sockaddr fromAddr;
#ifndef _WIN32
unsigned
#endif
int fromAddrLen = sizeof(sockaddr);
std::cout &lt;&lt; "等待接收..." &lt;&lt; std::endl;
while(true){
    if(recvfrom(udpSocket, buf, BufMaxSize, 0, &amp;fromAddr, &amp;fromAddrLen) != -1){
        std::cout &lt;&lt; "接收到数据：" &lt;&lt; buf &lt;&lt; std::endl;
        memset(buf, 0, sizeof(buf));
    }   
    else{
        std::cout &lt;&lt; "接收失败或发生错误！" &lt;&lt; std::endl;
        return -1; 
    }   
}</code></pre>
<p>最后记得做关闭工作</p>
<pre><code>#ifdef _WIN32
    WSACleanup();
    closesocket(udpSocket);
#else
    close(udpSocket);
#endif</code></pre>
<p><div class="panel panel-default collapse-panel box-shadow-wrap-lg"><div class="panel-heading panel-collapse" data-toggle="collapse" data-target="#collapse-bcbe59d0c5d70a0a3fd3613d1e0ff95717" aria-expanded="true"><div class="accordion-toggle"><span>udpServer.cpp 完整代码</span>
<i class="pull-right fontello icon-fw fontello-angle-right"></i>
</div>
</div>
<div class="panel-body collapse-panel-body">
<div id="collapse-bcbe59d0c5d70a0a3fd3613d1e0ff95717" class="collapse collapse-content"><p></p></p>
<pre><code>#include&lt;iostream&gt;
#include&lt;cstring&gt;
#ifdef _WIN32

#include&lt;winsock2.h&gt;

#else

#endif

int main(){
#ifdef _WIN32
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &amp;wsd)){
        std::cout &lt;&lt; "WSAStartup Error" &lt;&lt; std::endl;
        exit(-1);
    }   
#endif
    SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, 0); 
    sockaddr_in sain;
    sain.sin_family = AF_INET;
    sain.sin_addr.s_addr = htonl(INADDR_ANY);
    sain.sin_port = htons(atoi("50002"));

if(bind(udpSocket, (sockaddr *)&amp;sain, sizeof(sockaddr)) == -1){
        std::cout &lt;&lt; "绑定失败" &lt;&lt; std::endl;
    }   
    const size_t BufMaxSize = 1000;
    char buf[BufMaxSize] = {}; 
    sockaddr fromAddr;
#ifndef _WIN32
    unsigned
#endif
    int fromAddrLen = sizeof(sockaddr);
    std::cout &lt;&lt; "等待接收..." &lt;&lt; std::endl;
    while(true){
        if(recvfrom(udpSocket, buf, BufMaxSize, 0, &amp;fromAddr, &amp;fromAddrLen) != -1){
            std::cout &lt;&lt; "接收到数据：" &lt;&lt; buf &lt;&lt; std::endl;
            memset(buf, 0, sizeof(buf));
        }   
        else{
            std::cout &lt;&lt; "接收失败或发生错误！" &lt;&lt; std::endl;
            return -1; 
        }   
    }   
    //shutdown(udpSocket, SB_BOTH);
#ifdef _WIN32
    WSACleanup();
    closesocket(udpSocket);
#else
    close(udpSocket);
#endif

return 0;
}</code></pre>
<p><p></p></div></div></div></p>
<h3>客户端</h3>
<p>和服务器一样的先激活:</p>
<pre><code>WSADATA wsd;
if(WSAStartup(MAKEWORD(2, 2), &amp;wsd)){
    std::cout &lt;&lt; "WSAStartup Error" &lt;&lt; std::endl;
    exit(-1);
}</code></pre>
<p>创建socket：</p>
<pre><code>SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, 0);</code></pre>
<p>将目标远程主机的IP和端口信息填入sockaddr：</p>
<p>先写一个工具函数:</p>
<pre><code>sockaddr GetSockAddr(uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint16_t inPort){
    sockaddr addr;
    sockaddr_in *addrin = reinterpret_cast&lt;sockaddr_in*&gt;(&amp;addr);
    addrin-&gt;sin_family = AF_INET;
    addrin-&gt;sin_addr.S_un.S_un_b.s_b1 = b1;
    addrin-&gt;sin_addr.S_un.S_un_b.s_b2 = b2;
    addrin-&gt;sin_addr.S_un.S_un_b.s_b3 = b3;
    addrin-&gt;sin_addr.S_un.S_un_b.s_b4 = b4;
    addrin-&gt;sin_port = htons(inPort);

return addr;
}</code></pre>
<pre><code>sockaddr toAddr = GetSockAddr(127, 0, 0, 1, 50002);</code></pre>
<p><strong>sendTo函数</strong></p>
<blockquote>
<p>从UDP Socket发送数据<br />
int sendto(SOCKET s,const char <em>buf,int len,int flags,const struct sockaddr </em>to,int tolen);<br />
参数：</p>
</blockquote>
<blockquote>
<ul>
<li>s:  数据包应该使用的socket，如果没有绑定，socket库将自动绑定一个可用的端口。</li>
<li>buf:    待发送数据的起始地址的指针。可以是任何能够被转为char*的数据类型。</li>
</ul>
</blockquote>
<blockquote>
<ul>
<li>len:    待发送数据的大小。尽量避免发送数据大于1300字节的数据包，详见p75。</li>
<li>flags: 对控制发送的标志进行按位或运算的结果，该值通常取0即可。</li>
<li>to: 目标接收者的sockaddr。注意to的地址族必须和用于创建socket的地址族一致。</li>
<li>tolen:to的sockaddr的大小。对于IPv4,传入sizeof(sockaddr_in)即可。<br />
sendto操作成功返回等待发送的数据长度（说明成功进入发送队列），否则返回-1。</li>
</ul>
</blockquote>
<p>通过senTo函数发送数据：</p>
<pre><code>const size_t BufMaxSize = 1000;
char buf[BufMaxSize] = {};
sockaddr toAddr = GetSockAddr(127, 0, 0, 1, 50002); 
int toAddrLen = sizeof(sockaddr);
std::cout &lt;&lt; "&gt;&gt;&gt; ";
while(true){
    if(std::cin &gt;&gt; buf){
        sendto(udpSocket, buf, strlen(buf), 0, &amp;toAddr, toAddrLen);
        std::cout &lt;&lt; "已发送!" &lt;&lt;std::endl;
        std::cout &lt;&lt; "&gt;&gt;&gt; ";
        memset(buf, 0, sizeof(buf));
    }
}</code></pre>
<p>注意，这样发送给linux服务器带中文的字符串的话，可能出现乱码，因为linux通常为UTF-8编码，而windows通常为gb2312编码，所以我们可以在客户端实现两个编码转换函数，并在恰当时机转换：</p>
<pre><code>//UTF-8转GB2312
char* U2G(const char* utf8){
    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    wchar_t* wstr = new wchar_t[len+1];
    memset(wstr, 0, len+1);
    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
    len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* str = new char[len+1];
    memset(str, 0, len+1);
    WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
    if(wstr) delete[] wstr;
    return str;
}
//GB2312转UTF-8
char* G2U(const char* gb2312){
    int len = MultiByteToWideChar(CP_ACP, 0, gb2312, -1, NULL, 0);
    wchar_t* wstr = new wchar_t[len+1];
    memset(wstr, 0, len+1);
    MultiByteToWideChar(CP_ACP, 0, gb2312, -1, wstr, len);
    len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* str = new char[len+1];
    memset(str, 0, len+1);
    WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
    if(wstr) delete[] wstr;
    return str;
}</code></pre>
<p>发送改为:</p>
<pre><code>char *buf_UTF8 = G2U(buf);
sendto(udpSocket, buf_UTF8, strlen(buf_UTF8), 0, &amp;toAddr, toAddrLen);</code></pre>
<p>最后同样的关闭操作:</p>
<pre><code>closesocket(udpSocket);
WSACleanup();</code></pre>
<p><div class="panel panel-default collapse-panel box-shadow-wrap-lg"><div class="panel-heading panel-collapse" data-toggle="collapse" data-target="#collapse-a8dd38ba1110f10bf71c5b0448e9794b81" aria-expanded="true"><div class="accordion-toggle"><span>udpClient.cpp   完整代码</span>
<i class="pull-right fontello icon-fw fontello-angle-right"></i>
</div>
</div>
<div class="panel-body collapse-panel-body">
<div id="collapse-a8dd38ba1110f10bf71c5b0448e9794b81" class="collapse collapse-content"><p></p></p>
<pre><code>#include&lt;iostream&gt;
#include&lt;Winsock2.h&gt;
#include&lt;windows.h&gt;

//UTF-8转GB2312
char* U2G(const char* utf8){
    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    wchar_t* wstr = new wchar_t[len+1];
    memset(wstr, 0, len+1);
    MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
    len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* str = new char[len+1];
    memset(str, 0, len+1);
    WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
    if(wstr) delete[] wstr;
    return str;
}
//GB2312转UTF-8
char* G2U(const char* gb2312){
    int len = MultiByteToWideChar(CP_ACP, 0, gb2312, -1, NULL, 0);
    wchar_t* wstr = new wchar_t[len+1];
    memset(wstr, 0, len+1);
    MultiByteToWideChar(CP_ACP, 0, gb2312, -1, wstr, len);
    len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
    char* str = new char[len+1];
    memset(str, 0, len+1);
    WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
    if(wstr) delete[] wstr;
    return str;
}

sockaddr GetSockAddr(uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint16_t inPort){
    sockaddr addr;
    sockaddr_in *addrin = reinterpret_cast&lt;sockaddr_in*&gt;(&amp;addr);
    addrin-&gt;sin_family = AF_INET;
    addrin-&gt;sin_addr.S_un.S_un_b.s_b1 = b1;
    addrin-&gt;sin_addr.S_un.S_un_b.s_b2 = b2;
    addrin-&gt;sin_addr.S_un.S_un_b.s_b3 = b3;
    addrin-&gt;sin_addr.S_un.S_un_b.s_b4 = b4;
    addrin-&gt;sin_port = htons(inPort);

return addr;
}

int main(){
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &amp;wsd)){
        std::cout &lt;&lt; "WSAStartup Error" &lt;&lt; std::endl;
        exit(-1);
    }

SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, 0);
    const size_t BufMaxSize = 1000;
    char buf[BufMaxSize] = {};
        sockaddr toAddr = GetSockAddr(127, 0, 0, 1, 50002); 
    int toAddrLen = sizeof(sockaddr);
    std::cout &lt;&lt; "&gt;&gt;&gt; ";
    while(true){
        if(std::cin &gt;&gt; buf){
            char *buf_UTF8 = G2U(buf);
            sendto(udpSocket, buf_UTF8, strlen(buf_UTF8), 0, &amp;toAddr, toAddrLen);
            std::cout &lt;&lt; "已发送!" &lt;&lt;std::endl;
            std::cout &lt;&lt; "&gt;&gt;&gt; ";
            memset(buf, 0, sizeof(buf));
        }
    }

//shutdown(udpSocket, SB_BOTH);
    closesocket(udpSocket);

WSACleanup();

return 0;
}</code></pre>
<p><p></p></div></div></div></p>
<h3>测试</h3>
<p>注意，如果把服务器代码放到windows下执行，记得把客户端的转编码代码改下。</p>
<p>注意，编译使用C++11以上编译，链接时加入库:</p>
<pre><code>-lwsock32</code></pre>
<p><img src="https://hctra.cn/usr/uploads/2022/12/2301529164.png" alt="image.png" loading="lazy" style=""></p>
<p>将udpServer.cpp放到服务器上,服务器防火墙记得放行目标端口或暂时关闭防火墙。<br />
udpClient.cpp在本地（windows）。<br />
udpClient中的目标远程主机地址改为服务器ip地址,编译运行：</p>
<p>服务器:<br />
<img src="https://hctra.cn/usr/uploads/2022/12/4132439841.png" alt="image.png" loading="lazy" style=""></p>
<p>客户端：<br />
<img src="https://hctra.cn/usr/uploads/2022/12/2798816.png" alt="image.png" loading="lazy" style=""></p>
<h2>TCP Socket（单客户端连接）</h2>
<h3>服务器</h3>
<p>同样先激活winsock：</p>
<pre><code>#ifdef _WIN32
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &amp;wsd)){
        std::cout &lt;&lt; "WSAStartup Error" &lt;&lt; std::endl;
        return -1;
    }
#endif</code></pre>
<p>创建tcp类型socket：</p>
<pre><code>SOCKET tcpsocket = socket(AF_INET, SOCK_STREAM, 0);</code></pre>
<p>绑定本机地址和指定端口号:</p>
<pre><code>sockaddr_in sain;
sain.sin_family = AF_INET;
sain.sin_addr.s_addr = htonl(INADDR_ANY);
sain.sin_port = htons(atoi("50002"));
if(bind(tcpsocket, (sockaddr*)&amp;sain, sizeof(sockaddr)) == -1){
    std::cout &lt;&lt; "bind Error" &lt;&lt;  std::endl;
    return -1;
}</code></pre>
<p><strong>listen函数</strong></p>
<blockquote>
<p>用listen函数启动监听，等待客户端的连接：<br />
int listen(SOCKET sock, int backlog);<br />
backlog指队列允许传入的最大连接数，超过最大值的连接都将被丢弃。可以使用SOMAXCONN表示默认的backlog值。<br />
函数执行成功返回0，失败返回-1。</p>
</blockquote>
<p>使用listen函数开启监听：</p>
<pre><code>listen(tcpsocket, 10);</code></pre>
<p>主机针对每个保持的TCP连接，都需要一个独立的socket存储连接状态。<br />
这里先做只能连接单个客户端，创建连接客户端的socket：</p>
<pre><code>sockaddr clientAddr;        //

#ifndef _WIN32
    unsigned
#endif
    int clientAddrLen = sizeof(sockaddr);</code></pre>
<p><strong>accept函数</strong></p>
<blockquote>
<p>接受传入的连接并继续TCP握手过程，调用accept函数：<br />
SOCKET accept(SOCKET sock, sockaddr<em> addr, int</em> addrlen);<br />
参数:<br />
sock:     接收传入连接的监听socket<br />
addr:     将被写入请求连接的远程主机地址。同样不要手动填写<br />
addrlen:  指向addr缓冲区大小的指针。当真正写入地址之后，accept会更新该值。<br />
如果accept执行成功，将创建并返回一个可以与远程主机通信的新socket。</p>
</blockquote>
<p>接受传入的连接并继续TCP握手过程：</p>
<pre><code>SOCKET linkSocket = accept(tcpsocket, &amp;clientAddr, &amp;clientAddrLen);</code></pre>
<p><strong>recv函数</strong></p>
<blockquote>
<p>调用recv函数从一个连接的TCP socket接收数据：<br />
int recv(SOCKET s,char *buf,int len,int flags);<br />
参数：<br />
s:        待接收数据的socket<br />
buf:      数据接收缓冲区。<br />
len:      拷贝到buf中的数据的最大数量。<br />
flags:    标志位，大多数情况填0。<br />
调用成功返回接收的数据大小。如果返回0，说明连接的另一端发送了一个FIN数据包，承诺没有更多需要发送的数据。<br />
如果发生错误，返回-1<br />
默认情况下，如果socket的接收缓冲区中没有数据，recv函数将阻塞调用线程，直到数据流中的下一组数据到达或超时。</p>
</blockquote>
<p><strong>send函数</strong></p>
<blockquote>
<p>通过连接的socket使用send函数发送数据：<br />
因为连接的socket存储了远程主机地址信息，所以不需要传入地址参数：<br />
int send(SOCKET s,const char *buf,int len,int flags);<br />
参数：<br />
s:    用于发送数据的socket<br />
buf:  写入缓冲区。注意：和UDP不同，是将数据放到socket的输出缓冲区中，由socket库来决定在将来某一时刻发出。<br />
len:  传输的字节数量。注意：与UDP不同，不需要保持这个值低于链路层的MTU。<br />
flags:标志位，大多数情况下填0即可。<br />
send调用成功返回发送数据的大小，如果发送错误返回-1.<br />
默认情况下该函数会阻塞线程，直到调用超时或发送了足够的数据。<br />
非0的返回值不代表成功发送出去了，只说明数据被存入队列中等待发送。</p>
</blockquote>
<p>使用recv函数和send函数接收和响应客户端信息:</p>
<pre><code>const size_t BufMaxLen = 1000;
char buf[BufMaxLen] = {};
char sendBuf[BufMaxLen] = "服务器成功接收!";
while(true){
    int ret = recv(linkSocket, buf, BufMaxLen, 0);
    if(ret &gt; 0){
        std::cout &lt;&lt; "从客户端接收到数据:" &lt;&lt; buf &lt;&lt; std::endl;
        memset(buf, 0, BufMaxLen);
        send(linkSocket, sendBuf, strlen(sendBuf), 0);
    }
    else if(ret == 0){
        std::cout &lt;&lt; "客户端停止发送数据，准备关闭连接..." &lt;&lt; std::endl;
        break;
    }
    else{
        std::cout &lt;&lt; "recv发生错误！" &lt;&lt; std::endl;
    }
}</code></pre>
<p>最后关闭:</p>
<pre><code>#ifdef _WIN32
    closesocket(tcpsocket);
    closesocket(linkSocket);
    WSACleanup();
#else
    close(tcpsocket);
    close(linkSocket);
#endif
    std::cout &lt;&lt; "已关闭服务器Socket..." &lt;&lt; std::endl;</code></pre>
<p><div class="panel panel-default collapse-panel box-shadow-wrap-lg"><div class="panel-heading panel-collapse" data-toggle="collapse" data-target="#collapse-67096b3dd59e6ef5633d4ff7b89681ba89" aria-expanded="true"><div class="accordion-toggle"><span>tcpServer.cpp   完整代码</span>
<i class="pull-right fontello icon-fw fontello-angle-right"></i>
</div>
</div>
<div class="panel-body collapse-panel-body">
<div id="collapse-67096b3dd59e6ef5633d4ff7b89681ba89" class="collapse collapse-content"><p></p></p>
<pre><code>#include&lt;iostream&gt;
#include&lt;cstring&gt;
#ifdef _WIN32

#include&lt;winsock2.h&gt;

#else

#endif

int main(){
#ifdef _WIN32
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &amp;wsd)){
        std::cout &lt;&lt; "WSAStartup Error" &lt;&lt; std::endl;
        return -1;
    }
#endif
    SOCKET tcpsocket = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in sain;
    sain.sin_family = AF_INET;
    sain.sin_addr.s_addr = htonl(INADDR_ANY);
    sain.sin_port = htons(atoi("50002"));
    if(bind(tcpsocket, (sockaddr*)&amp;sain, sizeof(sockaddr)) == -1){
        std::cout &lt;&lt; "bind Error" &lt;&lt;  std::endl;
        return -1;
    }
    listen(tcpsocket, 10);
    std::cout &lt;&lt; "等待连接中..." &lt;&lt; std::endl;
    sockaddr clientAddr;        //

#ifndef _WIN32
    unsigned
#endif
    int clientAddrLen = sizeof(sockaddr);
    SOCKET linkSocket = accept(tcpsocket, &amp;clientAddr, &amp;clientAddrLen);
    std::cout &lt;&lt; "连接成功！" &lt;&lt; std::endl;
    const size_t BufMaxLen = 1000;
    char buf[BufMaxLen] = {};
    char sendBuf[BufMaxLen] = "服务器成功接收!";
    while(true){
        int ret = recv(linkSocket, buf, BufMaxLen, 0);
        if(ret &gt; 0){
            std::cout &lt;&lt; "从客户端接收到数据:" &lt;&lt; buf &lt;&lt; std::endl;
            memset(buf, 0, BufMaxLen);
            send(linkSocket, sendBuf, strlen(sendBuf), 0);
        }
        else if(ret == 0){
            std::cout &lt;&lt; "客户端停止发送数据，准备关闭连接..." &lt;&lt; std::endl;
            break;
        }
        else{
            std::cout &lt;&lt; "recv发生错误！" &lt;&lt; std::endl;

}
    }

#ifdef _WIN32
    closesocket(tcpsocket);
    closesocket(linkSocket);
    WSACleanup();
#else
    close(tcpsocket);
    close(linkSocket);
#endif
    std::cout &lt;&lt; "已关闭服务器Socket..." &lt;&lt; std::endl;

return 0;
}</code></pre>
<p><p></p></div></div></div></p>
<h3>客户端</h3>
<p>客户端没有新函数，直接看代码吧！</p>
<p><div class="panel panel-default collapse-panel box-shadow-wrap-lg"><div class="panel-heading panel-collapse" data-toggle="collapse" data-target="#collapse-4212662a71c36a831f0022990c6ac93c71" aria-expanded="true"><div class="accordion-toggle"><span>tcpClient.cpp   完整代码</span>
<i class="pull-right fontello icon-fw fontello-angle-right"></i>
</div>
</div>
<div class="panel-body collapse-panel-body">
<div id="collapse-4212662a71c36a831f0022990c6ac93c71" class="collapse collapse-content"><p></p></p>
<pre><code>#include&lt;iostream&gt;
#include&lt;winsock2.h&gt;
#include&lt;windows.h&gt;
#include&lt;memory&gt;
#include&lt;cstring&gt;

using namespace std;

return addr;
}

int main(){
    WSADATA wsd;
    if(WSAStartup(MAKEWORD(2, 2), &amp;wsd)){
        std::cout &lt;&lt; "WSAStartup Error" &lt;&lt; std::endl;
        return -1;
    }
    SOCKET tcpSocket = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr serverAddr = GetSockAddr(127, 0, 0, 1, 50002);   
    int serverAddrLen = sizeof(sockaddr);
    if(connect(tcpSocket, &amp;serverAddr, serverAddrLen) == -1){
        std::cout &lt;&lt; "connect Error!" &lt;&lt; std::endl;
        return -1;
    }
    std::cout &lt;&lt; "已成功连接到服务器" &lt;&lt; std::endl;
    //客户端的socket就是用于连接的socket
    const int BufMaxLen = 1000;
    char sendBuf[BufMaxLen] = {};
    char buf[BufMaxLen] = {};
    std::cout &lt;&lt; "&gt;&gt;&gt; ";
    while(true){
        if(std::cin &gt;&gt; sendBuf){
            if(strcmp(sendBuf, "exit") == 0){
                std::cout &lt;&lt; "正在关闭连接..." &lt;&lt; std::endl;
                break;
            }
            char *sendBuf_UTF8 = G2U(sendBuf);
            send(tcpSocket, sendBuf_UTF8, strlen(sendBuf_UTF8), 0);
            memset(sendBuf, 0, BufMaxLen);
            int ret = recv(tcpSocket, buf, BufMaxLen, 0);
            if(ret &gt; 0){
                std::cout &lt;&lt; "从服务器接收到回应：" &lt;&lt; U2G(buf) &lt;&lt; std::endl;
                memset(buf, 0, BufMaxLen);
            }
            std::cout &lt;&lt; "&gt;&gt;&gt; ";
        }
    }

shutdown(tcpSocket, SB_BOTH);
    closesocket(tcpSocket);
    WSACleanup();
    std::cout &lt;&lt; "已关闭客户端Socket..." &lt;&lt; std::endl;

return 0;
}</code></pre>
<p><p></p></div></div></div></p>
<h3>测试</h3>
<p>注意，如果把服务器代码放到windows下执行，记得把客户端的转编码代码改下。</p>
<p>测试方式同上面UDP。</p>
<p>客户端：<br />
<img src="https://hctra.cn/usr/uploads/2022/12/613413932.png" alt="image.png" loading="lazy" style=""><br />
服务器:<br />
<img src="https://hctra.cn/usr/uploads/2022/12/3499500968.png" alt="image.png" loading="lazy" style=""></p>
<h2>TCP Socket（多客户端连接）</h2>
<h3>服务端</h3>
<p>使用多线程，每响应一个客户端连接为它创建一个线程。<br />
多线程头文件：</p>
<pre><code>#include&lt;thread&gt;</code></pre>
<p>将之前的响应代码搬到函数中作为线程入口：</p>
<pre><code>void linkClientThread(SOCKET linkSocket, unsigned int linkId){
    printf("客户端(id:%d) 已连接！\n", linkId);
    const size_t BufMaxLen = 1000;
    char buf[BufMaxLen] = {};
    char sendBuf[BufMaxLen] = "服务器成功接收!";
    while(true){
        int ret = recv(linkSocket, buf, BufMaxLen, 0);
        if(ret &gt; 0){
            printf("从客户端(id:%d)接收到数据:%s\n", linkId, buf);
            memset(buf, 0, BufMaxLen);
            send(linkSocket, sendBuf, strlen(sendBuf), 0);
        }
        else if(ret == 0){
            printf("客户端(id:%d)停止发送数据，关闭连接...\n", linkId);
            break;
        }
        else{
            printf("recv发生错误！\n");
            break;
        }
    }

#ifdef _WIN32
    closesocket(linkSocket);
#else
    close(linkSocket);
#endif

}</code></pre>
<p>当接收到连接请求，为它单独创建一个线程服务：</p>
<pre><code>while(true){
    SOCKET linkSocket = accept(tcpsocket, &amp;clientAddr, &amp;clientAddrLen);
    std::thread linkThread(linkClientThread, linkSocket, ++linkId);
    linkThread.detach();
}</code></pre>
<p><div class="panel panel-default collapse-panel box-shadow-wrap-lg"><div class="panel-heading panel-collapse" data-toggle="collapse" data-target="#collapse-bf118a6415e04e45201d208d2613e54e65" aria-expanded="true"><div class="accordion-toggle"><span>tcpServer_multiConnection.cpp   完整代码</span>
<i class="pull-right fontello icon-fw fontello-angle-right"></i>
</div>
</div>
<div class="panel-body collapse-panel-body">
<div id="collapse-bf118a6415e04e45201d208d2613e54e65" class="collapse collapse-content"><p></p></p>
<pre><code>#include&lt;iostream&gt;
#include&lt;cstring&gt;
#include&lt;thread&gt;
#include&lt;vector&gt;
#ifdef _WIN32

#include&lt;winsock2.h&gt;

#else

#endif

void linkClientThread(SOCKET linkSocket, unsigned int linkId){
    printf("客户端(id:%d) 已连接！\n", linkId);
    const size_t BufMaxLen = 1000;
    char buf[BufMaxLen] = {};
    char sendBuf[BufMaxLen] = "服务器成功接收!";
    while(true){
        int ret = recv(linkSocket, buf, BufMaxLen, 0);
        if(ret &gt; 0){
            printf("从客户端(id:%d)接收到数据:%s\n", linkId, buf);
            memset(buf, 0, BufMaxLen);
            send(linkSocket, sendBuf, strlen(sendBuf), 0);
        }
        else if(ret == 0){
            printf("客户端(id:%d)停止发送数据，关闭连接...\n", linkId);
            break;
        }
        else{
            printf("recv发生错误！\n");
            break;
        }
    }

#ifdef _WIN32
    closesocket(linkSocket);
#else
    close(linkSocket);
#endif

}

unsigned int linkId = 0;
    sockaddr clientAddr;        //
#ifndef _WIN32
    unsigned
#endif
    int clientAddrLen = sizeof(sockaddr);
    while(true){
        SOCKET linkSocket = accept(tcpsocket, &amp;clientAddr, &amp;clientAddrLen);
        std::thread linkThread(linkClientThread, linkSocket, ++linkId);
        linkThread.detach();
    }

#ifdef _WIN32
    closesocket(tcpsocket);
    WSACleanup();
#else
    close(tcpsocket);
#endif
    std::cout &lt;&lt; "已关闭服务器Socket..." &lt;&lt; std::endl;

return 0;
}</code></pre>
<p><p></p></div></div></div></p>
<h3>客户端</h3>
<p>客户端直接继续使用之前的tcpClient.cpp即可，没有区别。</p>
<h3>测试</h3>
<p>同样的注意，如果把服务器代码放到windows下执行，记得把客户端的转编码代码改下。</p>
<p>服务器还是使用linux系统的，所有客户端在本地的windows执行：<br />
<strong>注意：server代码在linux编译时要加入-lpthread.h选项</strong>:</p>
<pre><code>g++ -g tcpServer_multiConnection.cpp -o tcpServer_multiConnection -std=c++11 -lpthread</code></pre>
<p>客户端1:<br />
<img src="https://hctra.cn/usr/uploads/2022/12/719758915.png" alt="image.png" loading="lazy" style=""></p>
<p>客户端2：<br />
<img src="https://hctra.cn/usr/uploads/2022/12/3828738954.png" alt="image.png" loading="lazy" style=""></p>
<p>服务器:<br />
<img src="https://hctra.cn/usr/uploads/2022/12/3588433591.png" alt="image.png" loading="lazy" style=""></p>
<hr />
<p>全部代码也可以在github上获取：<span class="external-link"><a class="no-external-link" href="https://github.com/cout357/cppSocketDemo" target="_blank"><i data-feather="external-link"></i>cppSocketDemo</a></span></p>
<blockquote>
<p>参考文献：《网络多人游戏架构与编程》</p>
</blockquote>

C++ 使用Socket实现主机间的UDP/TCP通信

前言

头文件

UDP Socket

服务器端

客户端

测试

TCP Socket（单客户端连接）

服务器

客户端

测试

TCP Socket（多客户端连接）

服务端

客户端

测试

1 条评论

发表评论取消回复

UE4常用蓝图Actions

学生管理系统

【python爬虫】爬取洛谷习题并转为md格式

[教程]字符动画制作

用代码实现解数独

[学习笔记]三维数学(1)-向量

蓝桥杯省模拟赛第十题（淹没城堡）

[学习笔记]unity3d-UGUI

【洛谷习题】P5318 【深基18.例3】查找文献

极致游戏21届校招游戏开发笔试编程题

C++ 使用Socket实现主机间的UDP/TCP通信

前言

头文件

UDP Socket

服务器端

客户端

测试

TCP Socket（单客户端连接）

服务器

客户端

测试

TCP Socket（多客户端连接）

服务端

客户端

测试

1 条评论

发表评论 取消回复

C++ 使用Socket实现主机间的UDP/TCP通信

发表评论取消回复