C++ 如何知道memcpy（）函数在完成打包过程中成功复制了内存？

我通过tcp/ip ssh隧道将一个包含120000的向量从我的计算机发送到服务器。每次，我发送250个double类型的值，服务器将它们发回给我，以确保我正确发送了数据。我使用函数read（）接收服务器中的数据。正如我们所知，read（）不能总是一次接收所有250个值（250*8=2000字节）。因此，我使用函数memcpy（）保存接收到的数据，直到它达到2000字节。但是，memcpy只能工作一次

例如，我发送250个值（2000字节）。服务器第一次接收1408字节。我使用memcpy（）将这些1406字节从缓冲区保存到一个数组中。服务器第二次接收594字节。我使用memcpy（）将这些592字节从缓冲区保存到同一个数组中。但是，我发现第二次，memcpy（）无法根据从服务器发送回我的计算机的值工作

<>服务器中的代码C++有两个目标： 1.每次接收250个数据。 2.每次都送回去

#include <stdio.h>
#include <iostream>
#include<vector>
#include <math.h>

extern "C"
void useCUDA();

#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

using namespace std;



int main()
{

    vector<double> Y;

    int lread = 250, nMu = 4, ltotal = 120000;


    int sock = socket(AF_INET, SOCK_STREAM, 0);

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));  
    serv_addr.sin_family = AF_INET; 
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); 
    serv_addr.sin_port = htons(54321); 
    connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));


    double* block_buffer_input;
    block_buffer_input = new double[lread];
    double* block_input;
    block_input = new double[lread];
    double* block_buffer_output;
    block_buffer_output = new double[lread];


    while (Y.size() < ltotal)
    {
        int nbyteread = 0;
        int nbytereadtimes = 0;

        while (nbyteread < 8 * lread)
        {

            nbytereadtimes = read(sock, reinterpret_cast<char*>(block_buffer_input), lread * sizeof(double));


            memcpy(block_input + nbyteread, block_buffer_input, nbytereadtimes);

            if (nbytereadtimes != 8 * lread && nbytereadtimes != 0)
                cout << Y.size() << ": " << nbytereadtimes << " " << block_input + nbyteread <<endl;


            nbyteread += nbytereadtimes;
        }

        Y.insert(Y.end(), &block_input[0], &block_input[lread]);

        cout << Y.size() << ": " << nbyteread << endl;


        int Sp = Y.size() - lread;
        for (int i = 0; i != lread; ++i)
        {
            block_buffer_output[i] = Y[Sp + i];
        }
        write(sock, (char*)block_buffer_output, lread * sizeof(double));



    }


    delete[] block_buffer_input;
    delete[] block_input;
    delete[] block_buffer_output;
    close(sock);


    return 0;
}

#包括
#包括
#包括
#包括
外部“C”
void useCUDA（）；
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
int main（）
{
向量Y；
int lread=250，nMu=4，ltotal=120000；
intsock=socket（AF_INET，sock_STREAM，0）；
服务地址中的结构sockaddr\u；
memset（&serv_addr，0，sizeof（serv_addr））；
serv_addr.sin_family=AF_INET；
serv_addr.sin_addr.s_addr=inet_addr（“127.0.0.1”）；
serv_addr.sin_port=htons（54321）；
连接（sock，（struct sockaddr*）&serv_addr，sizeof（serv_addr））；
双*块缓冲区输入；
块缓冲区输入=新的双[lread]；
双*块输入；
块_输入=新双[lread]；
双*块缓冲区输出；
块缓冲区输出=新的双[lread]；
而（Y.size（）cout如果将nbyteread添加到指向一个double数组的指针中，则实际上指的是nbyteread*sizeof（double）的地址（nbyteread元素的地址）

“不工作”不是一个问题描述，但是您在这里测试任何系统调用的结果都没有错误。因为每次我发回服务器中接收到的250个值，我都可以在我的计算机中检查它们的值。我发现如果需要两次读取（）数据，则第二次读取（）数据是不正确的。第二次读取（）数据与之前的250个值相同。例如：前250个值（从向量中的第1个元素到第250个元素）我读了一次，它们都是正确的。第二250个值（从向量中的第251个到第500个元素）我读了两次：176个元素和74个元素。176个元素都是正确的（从向量的251到426）。但是，74个元素不是。它们应该是向量的427到500个元素。但是现在它们是向量的177到250个元素。我认为这意味着memcpy（）第二次不工作。我不在乎你能在你的计算机上做什么。任何不检查系统调用错误的代码定义都是错误的。你也没有测试流结束。不。你应该使用char*block\u输入
memcpy(block_input + nbyteread, block_buffer_input, nbytereadtimes);