Question

我通过tcp / ip ssh隧道将包含120000的向量从我的计算机发送到服务器。每次，我发送250个double类型的值，并且服务器将它们发回给我，以确保我正确发送了数据。我使用read（）函数接收服务器中的数据。众所周知，read（）不能总是一次接收所有250个值（250 * 8 = 2000bytes）。因此，我使用函数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;
}

我想知道为什么memcpy（）第二次不起作用。

Answer 1

如果将nbyteread添加到指向double数组的指针，则实际上是指nbyteread的地址* sizeof（double）（nbyteread元素的地址）

memcpy(block_input + nbyteread, block_buffer_input, nbytereadtimes);

如何知道memcpy（）函数在完成包装时成功复制了内存？

1 个答案: