Udp网络通信协议（windows）

UDP（用户数据报协议）与TCP（传输控制协议）相比具有以下优缺点：

优点：

1. 低延迟： UDP 不涉及连接的建立和断开，因此通常具有比 TCP 更低的延迟，适用于对延迟要求较高的应用场景，如实时音视频传输、在线游戏等。

2. 无连接： UDP 是一种无连接的协议，不需要在通信的开始阶段进行三次握手，也不需要在通信结束时进行四次挥手，因此通信开销较小，更适用于频繁发送小量数据的场景。

3. 简单轻量： UDP 协议本身非常简单，实现起来比 TCP 更加轻量，可以更容易地集成到嵌入式系统或性能要求较高的应用中。

缺点：

1. 不可靠： UDP 不保证数据传输的可靠性，数据包可能丢失、重复、或者乱序到达。因此，需要在应用层自行处理数据的丢失和重传问题，增加了开发和维护的复杂性。

2. 无拥塞控制： UDP 不具备 TCP 的拥塞控制机制，数据包可能会因网络拥塞而丢失，对网络带宽的利用率较低，对网络负载也较高。

3. 有限的应用场景： 由于 UDP 不保证数据传输的可靠性，因此在需要可靠传输的场景（如文件传输、远程登录等）不适用。另外， UDP 也不适用于需要保证数据顺序的场景。

4. 缺乏流量控制： UDP 不具备 TCP 的流量控制机制，如果发送速度过快，可能会导致网络拥塞，影响网络性能和其他应用的通信。

客户端

编写UDP客户端的步骤如下：

1. 初始化Winsock库（仅在Windows平台）： 在使用任何套接字编程功能之前，需要初始化 Winsock 库。可以使用 WSAStartup 函数来完成初始化。

2. 创建套接字： 使用 socket 函数创建一个套接字。指定地址族为 AF_INET ，类型为 SOCK_DGRAM ，协议为 IPPROTO_UDP 。

3. 设置服务器地址和端口： 创建一个 sockaddr_in 结构体，并设置其中的地址族、IP地址和端口号，用于指定要连接的服务器。

4. 发送数据： 使用 sendto 函数向服务器发送数据报文。

5. 接收数据（可选）： 使用 recvfrom 函数从服务器接收响应数据报文。

6. 关闭套接字： 使用 closesocket 函数关闭套接字。

7. 清理Winsock库（仅在Windows平台）： 在程序退出前，使用 WSACleanup 函数清理 Winsock 库的资源。

#include <iostream>
#include <WinSock2.h>
#include <WS2tcpip.h> // 用于getaddrinfo函数

#pragma comment(lib, "ws2_32.lib")

int main() {
    // 初始化Winsock
    WSADATA wsData;
    WORD ver = MAKEWORD(2, 2);
    int wsOK = WSAStartup(ver, &wsData);
    if (wsOK != 0) {
        std::cerr << "Error: Can't initialize Winsock! Quitting" << std::endl;
        return 1;
    }

    // 创建socket
    SOCKET clientSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (clientSocket == INVALID_SOCKET) {
        std::cerr << "Error: Can't create socket! Quitting" << std::endl;
        WSACleanup();
        return 1;
    }

    // 设置服务器地址和端口
    sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(54000);
    inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);
   
    // 循环收发数据
    char sendData[4096]; // 存储发送的数据
    char buffer[4096]; // 存储接收的数据
    while (true) {
        // 获取用户输入
        std::cout << "Enter message to send (or type 'quit' to exit): ";
        std::cin.getline(sendData, sizeof(sendData));

        // 检查是否要退出循环
        if (strcmp(sendData, "quit") == 0) {
            break;
        }

        // 发送数据
        int sendResult = sendto(clientSocket, sendData, strlen(sendData), 0, (sockaddr*)&serverAddr, sizeof(serverAddr));
        if (sendResult == SOCKET_ERROR) {
            std::cerr << "Error: Failed to send data! Quitting" << std::endl;
            closesocket(clientSocket);
            WSACleanup();
            return 1;
        }

        std::cout << "Data sent to server: " << sendData << std::endl;

        // 接收数据
        sockaddr_in serverAddrReceived;
        int serverAddrSize = sizeof(serverAddrReceived);
        int bytesReceived = recvfrom(clientSocket, buffer, sizeof(buffer), 0, (sockaddr*)&serverAddrReceived, &serverAddrSize);
        if (bytesReceived == SOCKET_ERROR) {
            std::cerr << "Error: Failed to receive data! Quitting" << std::endl;
            closesocket(clientSocket);
            WSACleanup();
            return 1;
        }

        buffer[bytesReceived] = '\0'; // 添加字符串结束符
        std::cout << "Data received from server: " << buffer << std::endl;
    }


    // 关闭套接字
    closesocket(clientSocket);

    // 清理Winsock库
    WSACleanup();

    return 0;
}

服务端

编写UDP服务器的步骤如下：

1. 初始化Winsock： 在程序开始时调用 WSAStartup 函数初始化 Winsock 库。

2. 创建套接字： 使用 socket 函数创建一个UDP套接字，指定地址族为 AF_INET ，类型为 SOCK_DGRAM ，协议为 IPPROTO_UDP 。

3. 绑定端口： 使用 bind 函数将套接字绑定到服务器的IP地址和端口上，以侦听客户端发送的数据报文。

4. 接收数据： 使用 recvfrom 函数从客户端接收数据报文，并处理接收到的数据。

5. 发送数据（可选）： 如果需要，服务器可以使用 sendto 函数向客户端发送响应数据报文。

6. 循环监听： 在一个循环中持续监听客户端发送的数据报文，直到服务器关闭。

7. 关闭套接字： 在程序结束时调用 closesocket 函数关闭服务器的套接字。

8. 清理Winsock： 在程序结束时调用 WSACleanup 函数清理Winsock库。

#include <iostream>
#include <WinSock2.h>
#include <WS2tcpip.h> // 用于getaddrinfo函数

#pragma comment(lib, "ws2_32.lib")

int main() {
    // 初始化Winsock
    WSADATA wsData;
    WORD ver = MAKEWORD(2, 2);
    int wsOK = WSAStartup(ver, &wsData);
    if (wsOK != 0) {
        std::cerr << "Error: Can't initialize Winsock! Quitting" << std::endl;
        return 1;
    }

    // 创建socket
    SOCKET serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (serverSocket == INVALID_SOCKET) {
        std::cerr << "Error: Can't create socket! Quitting" << std::endl;
        WSACleanup();
        return 1;
    }

    // 绑定端口
    sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(54000);
    serverAddr.sin_addr.S_un.S_addr = INADDR_ANY;
   // inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr); // 设置服务器IP地址为指定接口的IP地址

    // 绑定端口
    if (bind(serverSocket, (sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
        std::cerr << "Error: Can't bind socket! Quitting" << std::endl;
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "UDP server started. Waiting for messages..." << std::endl;

    // 接收数据并回复
    char buffer[4096];
    sockaddr_in clientAddr;
    int clientAddrSize = sizeof(clientAddr);
    while (true) {
        
        int bytesReceived = recvfrom(serverSocket, buffer, sizeof(buffer), 0, (sockaddr*)&clientAddr, &clientAddrSize);
        if (bytesReceived == SOCKET_ERROR) {
            std::cerr << "Error: Failed to receive data! Quitting" << std::endl;
            closesocket(serverSocket);
            WSACleanup();
            return 1;
        }

        buffer[bytesReceived] = '\0'; // 添加字符串结束符
        std::cout << "Data received from client: " << buffer << std::endl;
        std::cout << "defdf";

        // 回复客户端
        const char* response = "Message received!";
        int sendResult = sendto(serverSocket, response, strlen(response), 0, (sockaddr*)&clientAddr, clientAddrSize);
        if (sendResult == SOCKET_ERROR) {
            std::cerr << "Error: Failed to send response! Quitting" << std::endl;
            closesocket(serverSocket);
            WSACleanup();
            return 1;
        }
    }

    // 关闭套接字
    closesocket(serverSocket);

    // 清理Winsock库
    WSACleanup();

    return 0;
}