C++ 以缓冲区大小接收数据的套接字服务器

我一个接一个地发送不同大小的数据包，如何以我发送的大小分别接收数据包，而不是在缓冲区中累积。似乎现在服务器会添加缓冲区，直到它填满缓冲区，然后我就可以处理它们了

例如：

缓冲区大小：84

从客户端发送：84字节、76字节、76字节、80字节

服务器中的接收：84字节，84字节，84字节，64字节

我希望收到我发送的邮件。可能吗

    int port = stoi(getConfig("server_port"));
    std::string ipAddress = getConfig("ip_address");

    // Create a socket
    int listening = socket(AF_INET, SOCK_STREAM, 0);
    if (listening < 0){
        std::cerr << "Can't create a socket!" << endl;
        Logger("Can't create a socket!");
        exit(-1);
    }
    std::cout << "The socket server was created successfully." << endl;

    // Bind the socket to a IP / port
    sockaddr_in hint;
    hint.sin_family = AF_INET;
    hint.sin_port = htons(port);
    inet_pton(AF_INET, ipAddress.c_str(), &hint.sin_addr);

    if (bind(listening, (sockaddr*)&hint, sizeof(hint)) < 0){
        cerr << "Can't bind to IP/port!" << endl;
        Logger("Can't bind to IP/port!");
        exit(-1);
    }

    // Mark the socket for listening in
    if (listen(listening, SOMAXCONN) < 0){
        cerr << "Can't listen!" << endl;
        Logger("Can't listen!");
        exit(-1);
    }

    // Accept a call
    sockaddr_in client;
    socklen_t clientSize = sizeof(client);
    char host[NI_MAXHOST];
    char svc[NI_MAXSERV];

    while(true){
        int clientSoket = accept(listening, (sockaddr*)&client, &clientSize);
        if(clientSoket < 0){
            cerr << "Problem with client connecting!" << endl;
            Logger("Problem with client connecting!");
            break;
        }
        cout << "The client whas conected successfully." << endl;

        memset(host, 0, NI_MAXHOST);
        memset(svc, 0, NI_MAXSERV);

        int result = getnameinfo((sockaddr*)&client, clientSize, host, NI_MAXHOST, svc, NI_MAXSERV, 0);
        if(result == 0) {
            cout << host << " connected on " << svc << endl;
        } else {
            inet_ntop(AF_INET, &client.sin_addr, host, NI_MAXHOST);
            cout << host << " connected on " << ntohs(client.sin_port) << endl;
        }

        // While receiving
        char buff[84];
        while(true){
            // Clear the buffer
            memset(buff, 0, sizeof(buff));

            // Wait for a message
            int bytesRecv = recv(clientSoket, buff, sizeof(buff), 0);
            if(bytesRecv < 0){
                cerr << "There was a connection issue!" << endl;
                Logger("There was a connection issue!");
                break;
            }

            if(bytesRecv == 0){
                cout << "The client disconnected." << endl;
                Logger("The client disconnected");
                break;
            }

            cout << "bytesRecv: " << bytesRecv << endl;
       }

       // Close the socket
       close(clientSoket);
    }

int-port=stoi（getConfig（“服务器端口”）；
std:：string ipAddress=getConfig（“ip_地址”）；
//创建一个套接字
int-listening=socket（AF\u-INET，SOCK\u-STREAM，0）；
如果（听力<0）{
不，流套接字不是那样工作的

流套接字是一个非结构化字节流，没有任何结构。在这方面，它与普通文件没有什么不同。如果您将不同大小的记录写入普通文件，并且现在准备将其读回，您希望如何读取不同大小的记录

无论您在这里给出的答案是什么，相同的答案都适用于套接字，另外一个问题是，套接字上的
read（）
不能保证您将读取多少，除非它小于或等于
read（）的
size
参数
。这是您从
read（）
获得的唯一保修

如果发送方调用了两次
write（）
（顺便说一下，套接字也不能保证无论您多么想
write
，都会写入多少，
write
也可以返回小于或等于其
size
参数的字节计数，这取决于您的代码如何处理），一次写入76字节，第二次写入84字节，
read（）
ing（假设缓冲区大小足够大），在初始读取时可以读取1到160字节之间的任意数量的字节

如果您希望实现某种形式的结构，即某种类型的记录，那么就由您自己来决定如何在这些约束条件下实现它。可以发送每个记录的大小（以字节为单位），然后再发送记录本身。或者做任何您想做的事情。请记住，您没有任何保证，不管怎样，一个
read（）
返回。例如，如果您首先以四字节值的形式发送记录计数。您的初始
read（）
可能返回一个、两个或三个字节。您的代码必须准备好处理任何可能发生的情况。
您是否也可以在此处添加服务器代码？这是否回答了您的问题？还有