C++实现TCP客户端及服务器Recv数据筛选处理详解

前言

在本篇文章中，我将为您详解如何使用C++编写TCP客户端和服务器程序，并说明如何接收数据并进行筛选处理。TCP（传输控制协议）是一种可靠的面向连接的协议，非常适合用于网络通信。通过使用TCP套接字编程，我们可以建立一个可靠的客户端和服务器之间的通信。

1. 程序概述

首先，我们需要创建一个TCP服务器程序，该程序将监听指定端口，并接收客户端的连接。一旦建立连接，服务器将接收从客户端发送的数据。然后，服务器将根据特定的规则对接收到的数据进行筛选和处理。接下来，我们将创建一个TCP客户端程序，它将连接到服务器并发送数据。客户端程序还可以接收来自服务器的响应数据，并对接收到的数据进行处理。

2. 服务器Recv数据筛选处理代码详解

```cpp

#include 
#include 
#include 

// 定义接收缓冲区的大小
#define MAX_BUFFER_SIZE 1024

int main()
{
    // 初始化Winsock库
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
        std::cout << "Failed to initialize Winsock" << std::endl;
        return 1;
    }

    // 创建服务器套接字
    SOCKET serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == INVALID_SOCKET)
    {
        std::cout << "Failed to create server socket" << std::endl;
        return 1;
    }

    // 绑定服务器套接字到指定IP地址和端口
    sockaddr_in serverAddress;
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_addr.s_addr = INADDR_ANY;
    serverAddress.sin_port = htons(8080);
    if (bind(serverSocket, (struct sockaddr*)&serverAddress, sizeof(serverAddress)) == SOCKET_ERROR)
    {
        std::cout << "Failed to bind server socket" << std::endl;
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }

    // 监听客户端连接
    if (listen(serverSocket, SOMAXCONN) == SOCKET_ERROR)
    {
        std::cout << "Failed to listen for client connections" << std::endl;
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Server listening on port 8080" << std::endl;

    // 接受客户端连接
    SOCKET clientSocket;
    sockaddr_in clientAddress;
    int clientAddressSize = sizeof(clientAddress);
    if ((clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddress, &clientAddressSize)) == INVALID_SOCKET)
    {
        std::cout << "Failed to accept client connection" << std::endl;
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Client connected" << std::endl;

    // 接收和筛选处理数据
    char buffer[MAX_BUFFER_SIZE];
    while (true)
    {
        memset(buffer, 0, sizeof(buffer));

        // 从客户端接收数据
        int bytesRead = recv(clientSocket, buffer, sizeof(buffer), 0);
        if (bytesRead > 0)
        {
            std::cout << "Received data from client: " << buffer << std::endl;

            // 对接收到的数据进行筛选和处理
            std::string receivedData(buffer);
            // 在此处添加筛选和处理逻辑

            // 向客户端发送响应数据
            std::string responseData = "Processed data";
            send(clientSocket, responseData.c_str(), responseData.length(), 0);
        }
        else if (bytesRead == 0)
        {
            std::cout << "Client disconnected" << std::endl;
            break;
        }
        else
        {
            std::cout << "Failed to receive data from client" << std::endl;
            break;
        }
    }

    // 关闭套接字并清理Winsock库
    closesocket(clientSocket);
    closesocket(serverSocket);
    WSACleanup();

    return 0;
}

``` 以上代码实现了一个简单的TCP服务器，它使用Winsock库来实现网络通信。服务器首先初始化Winsock库，然后创建一个套接字并绑定到指定的IP地址和端口。接下来，服务器开始监听客户端连接，并一旦有客户端连接，就接收并处理从客户端发送的数据。在接收到数据后，服务器可以根据特定的筛选和处理逻辑对数据进行处理，并将响应发送回客户端。

3. 客户端代码详解

```cpp

#include 
#include 
#include 

int main()
{
    // 初始化Winsock库
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
        std::cout << "Failed to initialize Winsock" << std::endl;
        return 1;
    }

    // 创建客户端套接字
    SOCKET clientSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (clientSocket == INVALID_SOCKET)
    {
        std::cout << "Failed to create client socket" << std::endl;
        return 1;
    }

    // 设置服务器相关信息
    sockaddr_in serverAddress;
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_port = htons(8080);
    serverAddress.sin_addr.s_addr = inet_addr("127.0.0.1");

    // 连接到服务器
    if (connect(clientSocket, (struct sockaddr*)&serverAddress, sizeof(serverAddress)) == SOCKET_ERROR)
    {
        std::cout << "Failed to connect to server" << std::endl;
        closesocket(clientSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Connected to server" << std::endl;

    // 发送数据到服务器
    std::string data = "Hello, server!";
    send(clientSocket, data.c_str(), data.length(), 0);

    // 接收服务器的响应数据
    char buffer[1024];
    memset(buffer, 0, sizeof(buffer));
    int bytesRead = recv(clientSocket, buffer, sizeof(buffer), 0);
    if (bytesRead > 0)
    {
        std::cout << "Received data from server: " << buffer << std::endl;

        // 在此处添加对接收到的数据的处理逻辑
    }
    else if (bytesRead == 0)
    {
        std::cout << "Disconnected from server" << std::endl;
    }
    else
    {
        std::cout << "Failed to receive data from server" << std::endl;
    }

    // 关闭套接字并清理Winsock库
    closesocket(clientSocket);
    WSACleanup();

    return 0;
}

``` 以上代码实现了一个简单的TCP客户端，它使用Winsock库来与服务器进行通信。客户端首先初始化Winsock库，然后创建一个套接字。接下来，客户端设置服务器的相关信息，并通过调用`connect()`函数与服务器建立连接。一旦连接建立，客户端发送数据到服务器，并等待接收来自服务器的响应数据。在接收到数据后，客户端可以根据需求对接收到的数据进行处理。

总结

本文中，我们详细介绍了如何使用C++编写TCP客户端和服务器，并解释了代码的用途和规范。通过实现TCP套接字编程，我们可以建立一个可靠的客户端和服务器之间的通信。服务器程序可以监听指定端口并接收客户端连接，然后根据特定的筛选和处理规则对接收到的数据进行处理，最后发送响应数据给客户端。客户端程序可以连接到服务器并发送数据，然后接收服务器的响应并进行相应的处理。这些示例代码可以帮助您理解如何实现TCP客户端和服务器，并为您的实际项目提供参考。