C++ - TCP/UDP网络编程

标签：recvBuf SOCKADDR UDP int sendBuf C++ TCP include wVersion

前言

socket编程分为TCP和UDP两个模块，其中TCP是可靠的、安全的，常用于发送文件等，而UDP是不可靠的、不安全的，常用作视频通话等。

如下图：

头文件与库：

#include <WinSock2.h>
​
#pragma comment(lib, "ws2_32.lib")

准备工作：

创建工程后，首先右键工程，选择属性

然后选择 C/C++ - 预处理器 - 预处理器定义

将字符串 _WINSOCK_DEPRECATED_NO_WARNINGS 添加到里面去，点击应用即可！

 

TCP

连接过程图：

 

创建tcp服务器和客户端都是按照上图的步骤来操作的！

1). 服务器

1.初始化套接字库,对应图中socket()

WORD wVersion;
WSADATA wsaData;
int err;
​
// 设置版本，可以理解为1.1
wVersion = MAKEWORD(1, 1);  // 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来
​
// 启动
err = WSAStartup(wVersion, &wsaData);

2.创建tcp套接字,对应图中socket()

// AF_INET:ipv4   AF_INET6:ipv6
SOCKET sockSrv = socket(AF_INET, SOCK_STREAM, 0);

3.绑定到本机, 对应图中bind()

// 准备绑定信息
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);   // 设置绑定网卡
addrSrv.sin_family = AF_INET;       // 设置绑定网络模式
addrSrv.sin_port = htons(6000);     // 设置绑定端口
// hton: host to network  x86:小端    网络传输：htons大端
​
// 绑定到本机
int retVal = bind(sockSrv, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));

4.监听,对应图中listen()

// 同时能接收10个链接，主要看参数二的设置个数
listen(sockSrv, 10);

5.接收连接请求，返回针对客户端的套接字,对应图中accept()

SOCKET sockConn = accept(sockSrv, (SOCKADDR *)&addrCli, &len);

6.发送数据,对应图中write()

sprintf_s(sendBuf, "hello client!\n");
int iSend = send(sockConn, sendBuf, strlen(sendBuf) + 1, 0);

7.接收数据,对应图中read()

recv(sockConn, recvBuf, 100, 0);

8.关闭套接字,对应图中close()

closesocket(sockConn);

9.清理套接字库

WSACleanup();

 

具体实现代码：

#include <iostream>
#include <stdio.h>
#include <WinSock2.h>
​
#pragma comment(lib, "ws2_32.lib")
​
​
int main(void) {
​
    // 1.初始化套接字库
    WORD wVersion;
    WSADATA wsaData;
    int err;
​
    // 设置版本，可以理解为1.1
    wVersion = MAKEWORD(1, 1);  // 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来
​
    // 启动
    err = WSAStartup(wVersion, &wsaData);
    if (err != 0) {
        return err;
    }
    // 检查：网络低位不等于1 || 网络高位不等于1
    if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
        // 清理套接字库
        WSACleanup();
        return -1;
    }
​
    // 2.创建tcp套接字       // AF_INET:ipv4   AF_INET6:ipv6
    SOCKET sockSrv = socket(AF_INET, SOCK_STREAM, 0);
​
    // 准备绑定信息
    SOCKADDR_IN addrSrv;
    addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);   // 设置绑定网卡
    addrSrv.sin_family = AF_INET;       // 设置绑定网络模式
    addrSrv.sin_port = htons(6000);     // 设置绑定端口
    // hton: host to network  x86:小端    网络传输：htons大端
​
    // 3.绑定到本机
    int retVal = bind(sockSrv, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
    if (retVal == SOCKET_ERROR) {
        printf("Failed bind:%d\n", WSAGetLastError());
        return -1;
    }
​
    // 4.监听，同时能接收10个链接
    if (listen(sockSrv, 10) == SOCKET_ERROR) {
        printf("Listen failed:%d", WSAGetLastError());
        return -1;
    }
​
    std::cout << "Server start at port: 6000" << std::endl;
​
    SOCKADDR_IN addrCli;
    int len = sizeof(SOCKADDR);
​
    char recvBuf[100];
    char sendBuf[100];
    while (1) {
        // 5.接收连接请求，返回针对客户端的套接字
        SOCKET sockConn = accept(sockSrv, (SOCKADDR *)&addrCli, &len);
        if (sockConn == SOCKET_ERROR) {
            //printf("Accept failed:%d", WSAGetLastError());
            std::cout << "Accept failed: " << WSAGetLastError() << std::endl;
            break;
        }
​
        //printf("Accept client IP:[%s]\n", inet_ntoa(addrCli.sin_addr));
        std::cout << "Accept client IP: " << inet_ntoa(addrCli.sin_addr) << std::endl;
​
        // 6.发送数据
        sprintf_s(sendBuf, "hello client!\n");
        int iSend = send(sockConn, sendBuf, strlen(sendBuf) + 1, 0);
        if (iSend == SOCKET_ERROR) {
            std::cout << "send failed!\n";
            break;
        }
​
        // 7.接收数据
        recv(sockConn, recvBuf, 100, 0);
        std::cout << recvBuf << std::endl;
​
        // 关闭套接字
        closesocket(sockConn);
    }
​
​
    // 8.关闭套接字
    closesocket(sockSrv);
​
    // 9.清理套接字库
    WSACleanup();
​
    return 0;
}
​

 

2). 客户端

1.初始化套接字库,对应图中socket()

WORD wVersion;
WSADATA wsaData;
int err;
​
// 可以理解为1.1
wVersion = MAKEWORD(1, 1);  // 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来
​
// 启动
err = WSAStartup(wVersion, &wsaData);
​
// 创建TCP套接字
SOCKET sockCli = socket(AF_INET, SOCK_STREAM, 0);

2.连接服务器,对应图中connect()

// 连接服务器
int err_log = connect(sockCli, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));

3.发送数据到服务器,对应图中write()

char sendBuf[] = "你好，服务器，我是客户端！";
send(sockCli, sendBuf, strlen(sendBuf) + 1, 0);

4.接收服务器的数据,对应图中read()

char recvBuf[100];
recv(sockCli, recvBuf, sizeof(recvBuf), 0);

5.关闭套接字并清除套接字库,对应图中close()

closesocket(sockCli);
WSACleanup();

 

具体实现代码：

#include <iostream>
#include <WinSock2.h>
​
​
#pragma comment(lib, "ws2_32.lib")
​
​
int main(void) {
​
    // 1.初始化套接字库
    WORD wVersion;
    WSADATA wsaData;
    int err;
​
    // 可以理解为1.1
    wVersion = MAKEWORD(1, 1);  // 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来
​
    // 启动
    err = WSAStartup(wVersion, &wsaData);
    if (err != 0) {
        return err;
    }
    // 检查：网络地位不等于1 || 网络高位不等于1
    if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
        // 清理套接字库
        WSACleanup();
        return -1;
    }
​
    // 创建TCP套接字
    SOCKET sockCli = socket(AF_INET, SOCK_STREAM, 0);
​
    SOCKADDR_IN addrSrv;
    addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");  // 服务器地址
    addrSrv.sin_port = htons(6000);     // 端口号
    addrSrv.sin_family = AF_INET;       // 地址类型(ipv4)
​
    // 2.连接服务器
    int err_log = connect(sockCli, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
    if (err_log == 0) {
        printf("连接服务器成功！\n");
    
    } else {
        printf("连接服务器失败！\n");
        return -1;
    }
​
​
    char recvBuf[100];
    char sendBuf[] = "你好，服务器，我是客户端！";
    // 3.发送数据到服务器
    send(sockCli, sendBuf, strlen(sendBuf) + 1, 0);
​
    // 4.接收服务器的数据
    recv(sockCli, recvBuf, sizeof(recvBuf), 0);
    std::cout << recvBuf << std::endl;
​
​
    // 5.关闭套接字并清除套接字库
    closesocket(sockCli);
    WSACleanup();
​
    system("pause");
​
    return 0;
}
​

运行效果：

 

3). TCP聊天小项目

下面是根据上面的代码修改的一个聊天小项目(使用到了多线程)

只有一个服务器，服务器一直开启等待客户端连接； 客户都安可以开启多个，且可以一直连续的与服务器进行发送接收消息； 服务器给客户端发送数据，得通过1 - 9来区分到底给那个客户端发送消息，例如给第二个客户端发送消息：2你好，客户端 客户端那边接收到的数据是：你好，客户端

服务器代码：

#include <iostream>
#include <WinSock2.h>
#include <stdio.h>
#include <Windows.h>
#include <process.h>
#include <vector>
#include <conio.h>
#include <string.h>
#include <string>
​
#pragma comment(lib, "ws2_32.lib")
​
​
SOCKET sockSrv;
std::vector<SOCKET> vec_sockConn;
std::vector<SOCKADDR_IN> vec_sockaddr_in;
std::vector<int> vec_sockIndex;
​
​
// 这个结构体用作线程参数
typedef struct SERVER_CLIENT {
    SOCKET server;
    SOCKADDR_IN client;
    int clientIndex;
}SC;
​
​
​
// 判断有没有断开连接
bool IsSocketClosed(SOCKET clientSocket) {
    bool ret = false;
    HANDLE closeEvent = WSACreateEvent();
    WSAEventSelect(clientSocket, closeEvent, FD_CLOSE);
​
    DWORD dwRet = WaitForSingleObject(closeEvent, 0);
​
    if (dwRet == WSA_WAIT_EVENT_0)
        ret = true;
    else if (dwRet == WSA_WAIT_TIMEOUT)
        ret = false;
​
    WSACloseEvent(closeEvent);
    return ret;
}
​
​
// 接收请求
unsigned int WINAPI  ThreadAccept(LPVOID p) {
    static int i = 0;
    while (1) {
        SOCKADDR_IN addrCli;
        int len = sizeof(SOCKADDR);
​
        // 5.接收连接请求，返回针对客户端的套接字
        SOCKET sockConn = accept(sockSrv, (SOCKADDR *)&addrCli, &len);
        if (sockConn == SOCKET_ERROR) {
            printf("Accept failed:%d", WSAGetLastError());
        }
​
        // 存储当前服务器与客户端 连接绑定的socket
        vec_sockIndex.emplace_back(i++);
        vec_sockaddr_in.emplace_back(addrCli);
        vec_sockConn.emplace_back(sockConn);
​
        printf("\033[0;%d;40m客户端[%d]上线\033[0m\n", 31, i);
    }
    
​
    return 0;
}
​
unsigned int WINAPI  _ThreadRecv(LPVOID p) {
    char recvBuf[100];
    memset(recvBuf, 0, 100);
​
    SC _sc = *(SC *)p;
    
    while (1) {
        Sleep(20);
​
        if (IsSocketClosed(_sc.server) == true) {
            printf("客户端 [%d] 断开连接！\n", _sc.clientIndex + 1);
            break;
        }
​
​
        // 接收数据
        recv(_sc.server, recvBuf, 100, 0);
        if (strlen(recvBuf) == 0) {
            continue;
        }
    
        printf("接收到客户端 [%d] 的消息：%s\n", _sc.clientIndex + 1, recvBuf);
        memset(recvBuf, 0, 100);
    }
    return 0;
}
​
unsigned int WINAPI  ThreadRecv(LPVOID p) {
​
    static int index = 0;
​
    while (1) {
        // 还没有客户端与服务器进行连接
        if (vec_sockConn.size() == 0) {
            continue;
        }
​
        // 接收线程已经开启和客户端个数相等
        if (vec_sockConn.size()  == index) {
            continue;
        }
​
        SC sc;
        sc.server = vec_sockConn.at(index);
        sc.client = vec_sockaddr_in.at(index);
        sc.clientIndex = vec_sockIndex.at(index);
​
        HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, _ThreadRecv, (void *)&sc, 0, NULL);
​
        index++;
        Sleep(20);
    }
​
    return 0;
}
​
​
​
int main(void) {
​
    // 1.初始化套接字库
    WORD wVersion;
    WSADATA wsaData;
    int err;
​
    // 设置版本，可以理解为1.1
    wVersion = MAKEWORD(1, 1);  // 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来
​
    // 启动
    err = WSAStartup(wVersion, &wsaData);
    if (err != 0) {
        return err;
    }
    // 检查：网络低位不等于1 || 网络高位不等于1
    if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
        // 清理套接字库
        WSACleanup();
        return -1;
    }
​
    // 2.创建tcp套接字       // AF_INET:ipv4   AF_INET6:ipv6
    sockSrv = socket(AF_INET, SOCK_STREAM, 0);
​
    // 准备绑定信息
    SOCKADDR_IN addrSrv;
    addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);   // 设置绑定网卡
    addrSrv.sin_family = AF_INET;       // 设置绑定网络模式
    addrSrv.sin_port = htons(6000);     // 设置绑定端口
    // hton: host to network  x86:小端    网络传输：htons大端
​
    // 3.绑定到本机
    int retVal = bind(sockSrv, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
    if (retVal == SOCKET_ERROR) {
        printf("Failed bind:%d\n", WSAGetLastError());
        return -1;
    }
​
    // 4.监听，同时接收10个链接
    if (listen(sockSrv, 10) == SOCKET_ERROR) {
        printf("Listen failed:%d", WSAGetLastError());
        return -1;
    }
​
    std::cout << "Server start at port: 6000" << std::endl;
​
​
    // 线程句柄             // 创建线程
    HANDLE hThread_1 = (HANDLE)_beginthreadex(NULL, 0, ThreadAccept, NULL, 0, NULL);
    HANDLE hThread_2 = (HANDLE)_beginthreadex(NULL, 0, ThreadRecv, NULL, 0, NULL);
​
​
    //uiInit();
    //editPrint(0, ">");
​
​
    char sendBuf[100];
    while (1) {
​
        //printf("请输入发送内容：");
​
        char c = getchar();             // 输入发送给谁
        scanf_s("%s", sendBuf, 100);    // 输入发送的内容
​
        if (strlen(sendBuf) == 0) {
            printf("输入内容为空或者超长！\n");
        }
​
        // 1 至 9
        if (c < '1' || c > '9' || vec_sockConn.size() == 0 || c - '0' >= vec_sockConn.size() + 1) {
            while ((c = getchar()) != '\n');    // 清空输入缓冲区
            memset(sendBuf, 0, 100);
            printf("输入内容不符合规则！\n");
            continue;
        }
​
​
​
        // 发送数据
        int index = --c - '0';  // 因为下标是从零开始的，所以c要先自减
        int iSend = send(vec_sockConn.at(index) , sendBuf, strlen(sendBuf) + 1, 0);
        if (iSend == SOCKET_ERROR) {
            std::cout << "send failed!\n";
            break;
        }
​
​
        memset(sendBuf, 0, 100);
        while ((c = getchar()) != '\n');    // 清空输入缓冲区
    }
​
    // 关闭套接字
    std::vector<SOCKET>::iterator it = vec_sockConn.begin();
    for (; it != vec_sockConn.end(); it++) {
        closesocket((SOCKET)(*it));
    }
​
​
    WaitForSingleObject(hThread_1, INFINITE);
    WaitForSingleObject(hThread_2, INFINITE);
​
    CloseHandle(hThread_1);
    CloseHandle(hThread_2);
​
    // 7.关闭套接字
    closesocket(sockSrv);
​
    // 8.清理套接字库
    WSACleanup();
​
    return 0;
}
​

 

客户端代码：

#include <iostream>
#include <WinSock2.h>
#include <process.h>
#include <stdio.h>
​
#pragma comment(lib, "ws2_32.lib")
​
SOCKET sockCli;
​
​
// 判断有没有断开连接
bool IsSocketClosed(SOCKET clientSocket) {
    bool ret = false;
    HANDLE closeEvent = WSACreateEvent();
    WSAEventSelect(clientSocket, closeEvent, FD_CLOSE);
​
    DWORD dwRet = WaitForSingleObject(closeEvent, 0);
​
    if (dwRet == WSA_WAIT_EVENT_0)
        ret = true;
    else if (dwRet == WSA_WAIT_TIMEOUT)
        ret = false;
​
    WSACloseEvent(closeEvent);
    return ret;
}
​
​
unsigned int WINAPI  ThreadRecv(LPVOID p) {
    char recvBuf[100];
    memset(recvBuf, 0, 100);
​
    while (1) {
        Sleep(20);
​
        if (IsSocketClosed(sockCli) == true) {
            printf("服务器 断开连接！\n");
            break;
        }
​
        // 接收服务器的数据
        recv(sockCli, recvBuf, sizeof(recvBuf), 0);
        if (strlen(recvBuf) == 0) continue;
​
        std::cout << recvBuf << std::endl;
        memset(recvBuf, 0, 100);
    }
​
​
    return 0;
}
​
int main(void) {
​
    // 1.初始化套接字库
    WORD wVersion;
    WSADATA wsaData;
    int err;
​
    // 可以理解为1.1
    wVersion = MAKEWORD(1, 1);  // 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来
​
    // 启动
    err = WSAStartup(wVersion, &wsaData);
    if (err != 0) {
        return err;
    }
    // 检查：网络地位不等于1 || 网络高位不等于1
    if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
        // 清理套接字库
        WSACleanup();
        return -1;
    }
​
    // 创建TCP套接字
    sockCli = socket(AF_INET, SOCK_STREAM, 0);
​
    SOCKADDR_IN addrSrv;
    addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");  // 服务器地址
    addrSrv.sin_port = htons(6000);     // 端口号
    addrSrv.sin_family = AF_INET;       // 地址类型(ipv4)
​
    // 连接服务器
    int err_log = connect(sockCli, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
    if (err_log == 0) {
        printf("连接服务器成功！\n");
​
    } else {
        printf("连接服务器失败！\n");
        return -1;
    }
​
    // 线程句柄             // 创建线程
    HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, ThreadRecv, NULL, 0, NULL);
​
​
    char sendBuf[100];
    while (1) {
​
        //printf("请输入发送内容：");
        scanf_s("%s", sendBuf, 100);
​
        // 发送数据到服务器
        send(sockCli, sendBuf, strlen(sendBuf) + 1, 0);
​
        memset(sendBuf, 0, 100);
        char c;
        while ((c = getchar()) != '\n');
    }
​
​
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
​
​
    // 关闭套接字并清除套接字库
    closesocket(sockCli);
    WSACleanup();
​
    system("pause");
​
    return 0;
}
​

 

运行效果：

 

 

UDP

UDP就比较简单了，步骤比tcp要少一些。

连接过程图：

 

 

1). 服务器

1.初始化套接字库

WORD wVersion;
WSADATA wsaData;
int err;
​
wVersion = MAKEWORD(1, 1);

2.创建套接字

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

3.绑定

// SOCKADDR_IN addrSrv; 省略了定义和赋值
bind(sockSrv, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));

4.接收数据

char recvBuf[100];
recvfrom(sockSrv, recvBuf, 100, 0, (SOCKADDR *)&addrCli, &len);

5.发送数据

char sendBuf[] = "hello Client，I'm Server！\n";
sendto(sockSrv, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR *)&addrCli, len);

6.关闭

closesocket(sockSrv);
WSACleanup();

 

具体实现代码：

#include <WinSock2.h>
#include <iostream>
​
#pragma comment(lib, "ws2_32.lib")
​
int main(void) {
    // 初始化套接字库
    WORD wVersion;
    WSADATA wsaData;
    int err;
​
    wVersion = MAKEWORD(1, 1);
    err = WSAStartup(wVersion, &wsaData);
    if (err != 0) {
        return err;
    }
​
    if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
        WSACleanup();
        return -1;
    }
​
    // 创建套接字
    SOCKET sockSrv = socket(AF_INET, SOCK_DGRAM, 0);
​
    SOCKADDR_IN addrSrv;
    addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
    addrSrv.sin_family = AF_INET;
    addrSrv.sin_port = htons(6001);
​
    // 绑定到本机6001端口
    bind(sockSrv, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
​
    // 接收请求，处理请求
    SOCKADDR_IN addrCli;
    int len = sizeof(SOCKADDR);
​
    char sendBuf[] = "hello Client，I'm Server！\n";
    char recvBuf[100];
​
    std::cout << "start UDP server with port 6001" << std::endl;
    while (1) {
        // 接收数据
        recvfrom(sockSrv, recvBuf, 100, 0, (SOCKADDR *)&addrCli, &len);
        std::cout << "Recv:" << recvBuf << std::endl;
​
        // 发送数据
        sendto(sockSrv, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR *)&addrCli, len);
        std::cout << "Send:" << sendBuf << std::endl;
    }
​    // 关闭
    closesocket(sockSrv);
    WSACleanup();
​
    return 0;
}
​

 

2). 客户端

1.初始化套接字库

WORD wVersion;
WSADATA wsaData;
int err;
​
wVersion = MAKEWORD(1, 1);

2.创建UDP套接字

SOCKET sockCli = socket(AF_INET, SOCK_DGRAM, 0);
SOCKADDR_IN addrSrv;

3.接收数据

char recvBuf[100];
recvfrom(sockCli, recvBuf, 100, 0, (SOCKADDR *)&addrCli, &len);

4.发送数据

char sendBuf[] = "hello Client，I'm Server！\n";
sendto(sockCli, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR *)&addrSrv, len);

5.关闭

closesocket(sockSrv);
WSACleanup();

 

具体实现代码：

#include <WinSock2.h>
#include <iostream>
​
#pragma comment(lib, "ws2_32.lib")
​
​
int main(void) {
​
    // 初始化套接字库
    WORD wVersion;
    WSADATA wsaData;
    int err;
​
    wVersion = MAKEWORD(1, 1);
    err = WSAStartup(wVersion, &wsaData);
    if (err != 0) {
        return err;
    }
​
    if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
        WSACleanup();
        return -1;
    }
​
    // 创建UDP套接字
    SOCKET sockCli = socket(AF_INET, SOCK_DGRAM, 0);
    SOCKADDR_IN addrSrv;
    addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    addrSrv.sin_family = AF_INET;
    addrSrv.sin_port = htons(6001);
​
    SOCKADDR_IN addrCli;
    int len = sizeof(SOCKADDR);
​
    char sendBuf[] = "hello, I'm Client!\n";
    char recvBuf[100];
​    // 发送数据
    std::cout << "send to Server: " << sendBuf << std::endl;
    sendto(sockCli, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR *)&addrSrv, len);
​    
    // 接收数据
    recvfrom(sockCli, recvBuf, 100, 0, (SOCKADDR *)&addrCli, &len);
    std::cout << "recv from: " << recvBuf << std::endl;
​
​    // 关闭
    closesocket(sockCli);
    WSACleanup();
​
    system("pause");
    return 0;
}
​

 

运行效果：

 

总结

socket的具体细节用法我不太清楚，现阶段也只是熟悉TCP的一些简单操作，UDP的话也还不是太懂，不懂的是不知道在具体项目中该如何进行使用它们。 那个TCP的小项目也只是自己琢磨搞出来的，不知掉具体项目会不会这样去写！

 

————————————————

版权声明：本文为CSDN博主「cpp_learners」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/cpp_learner/article/details/121798854

标签：recvBuf,SOCKADDR,UDP,int,sendBuf,C++,TCP,include,wVersion
From： https://www.cnblogs.com/zhuchunlin/p/17032316.html