手写 C++ TCP 服务器：自定义协议与粘包处理实战

Decode 函数做了三件事：判断是否有完整头部、验证数据长度是否匹配、解析并清理缓冲区。这是处理粘包的核心逻辑。

请求与响应结构

请求 (Request) 客户端发送运算指令，如 10 + 5。

class request {
public:
    int x_;
    int y_;
    char op_;
    // ... 序列化与反序列化方法 ...
};

响应 (Response) 服务器返回计算结果及状态码。

class response {
public:
    int result_;
    int code_;
    // ... 序列化与反序列化方法 ...
};

服务端核心逻辑

服务端使用 fork() 创建子进程处理每个连接，主循环监听新请求。关键在于接收缓冲区的管理：

while (true) {
    int sockfd = listenfd_.Accept(&client_port, &client_ip);
    if (sockfd < 0) continue;
    
    if (fork() == 0) {
        listenfd_.Close();
        std::string inbuffer_stream;
        
        while (1) {
            char buffer[1280];
            ssize_t s = read(sockfd, buffer, sizeof buffer - 1);
            
            if (s > 0) {
                buffer[s] = 0;
                inbuffer_stream += buffer; // 累加到缓冲区
                
                // 循环尝试解析完整报文
                while (true) {
                    std::string info = callback_(inbuffer_stream);
                    if (info.empty()) break;
                    write(sockfd, info.c_str(), info.size());
                }
            } else if (s == 0 || s < 0) {
                break;
            }
        }
        close(sockfd);
        exit(0);
    }
    close(sockfd);
}

这里的关键在于 callback_ 内部调用了 Decode。如果收到的数据不完整，Decode 返回失败，callback_ 返回空字符串，循环继续等待更多数据。只有当缓冲区凑齐一个完整报文时，才会进行业务处理并发送响应。

完整代码示例

服务端 (main.cpp)

#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <functional>

// ... Socket 类封装 ...
// ... CalculatorServer 类封装 ...

class TcpServer {
public:
    TcpServer(uint16_t port, std::string ip, std::function<std::string(std::string &)> callback)
        : port_(port), ip_(ip), callback_(callback) {}

    void InitServer() {
        listenfd_.Bind(port_, ip_);
        listenfd_.Listen();
        std::cout << "init server successful!" << std::endl;
    }

    void start() {
        signal(SIGCHLD, SIG_IGN);
        signal(SIGPIPE, SIG_IGN);
        while (true) {
            uint16_t client_port;
            std::string client_ip;
            int sockfd = listenfd_.Accept(&client_port, &client_ip);
            if (sockfd < 0) continue;

            if (fork() == 0) {
                listenfd_.Close();
                std::string inbuffer_stream;
                while (1) {
                    char buffer[1280];
                    ssize_t s = read(sockfd, buffer, sizeof buffer - 1);
                    if (s > 0) {
                        buffer[s] = 0;
                        inbuffer_stream += buffer;
                        while (true) {
                            std::string info = callback_(inbuffer_stream);
                            if (info.empty()) break;
                            write(sockfd, info.c_str(), info.size());
                        }
                    } else {
                        break;
                    }
                }
                close(sockfd);
                exit(0);
            }
            close(sockfd);
        }
    }
private:
    Socket listenfd_;
    uint16_t port_;
    std::string ip_;
    std::function<std::string(std::string &)> callback_;
};

int main(int argc, char* argv[]) {
    if (argc != 3) { exit(0); }
    uint16_t server_port = std::atoi(argv[2]);
    std::string server_ip = argv[1];
    
    CalculatorServer cal;
    TcpServer* ser = new TcpServer(server_port, server_ip,
        std::bind(&CalculatorServer::Calculator, &cal, std::placeholders::_1));
    
    ser->InitServer();
    ser->start();
    return 0;
}

客户端 (client.cpp)

#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <ctime>
#include "Protocol.hpp"
#include "Socket.hpp"

static void Usage(const std::string &proc) {
    std::cout << "Usage: " << proc << " serverip serverport\n" << std::endl;
}

int main(int argc, char *argv[]) {
    if (argc != 3) { Usage(argv[0]); exit(0); }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);
    
    Socket sockfd;
    sockfd.Connect(serverport, serverip);
    srand(time(nullptr) ^ getpid());
    
    int cnt = 1;
    const std::string opers = "+-*/%";
    std::string inbuffer_stream;
    
    while (cnt <= 10) {
        std::cout << "===============第" << cnt << "次测试.....\n" << std::endl;
        int x = rand() % 100 + 1;
        usleep(1234);
        int y = rand() % 100;
        usleep(4321);
        char oper = opers[rand() % opers.size()];
        
        request req(x, y, oper);
        req.DebugPrint();
        
        std::string package = req.serialization();
        package = Encode(package);
        std::cout << package << std::endl;
        
        write(sockfd.fd(), package.c_str(), package.size());
        
        char buffer[128];
        ssize_t n = read(sockfd.fd(), buffer, sizeof(buffer) - 1);
        if (n > 0) {
            buffer[n] = 0;
            inbuffer_stream += buffer;
            
            std::string content;
            bool r = Decode(inbuffer_stream, &content);
            assert(r);
            
            response resp;
            r = resp.Deserialization(content);
            assert(r);
            resp.DebugPrint();
        }
        std::cout << "=================================================\n" << std::endl;
        sleep(1);
        cnt++;
    }
    sockfd.Close();
    return 0;
}

总结

TCP 编程的本质不是简单的收发数据，而是如何正确解析数据的边界。通过引入自定义协议（长度头 + 内容），配合序列化和反序列化机制，我们可以可靠地处理粘包和半包问题。上述代码提供了一个完整的 C++ 实现参考，涵盖了 Socket 封装、多线程模型及协议解析逻辑。在实际开发中，可根据需求扩展协议字段或更换传输介质，但核心思想保持一致。