正在尝试通过tcp发送向量 我尝试在C++中用TCP发送一个接收多维向量，但是我一直在得到一个分割错误。我试图一次发送一个向量，而不是单个整数，以减少延迟。我想知道我应该如何序列化和反序列化一个向量（没有像Boost这样的库）

服务器：

vector< vector<int> > contours = { {3,6,8}, {7,24,64}, {87,399} };
int len = 3;
int size =0;

while(waitKey(10) != 'q')
{      

    send(new_socket, &len, sizeof(int),0); //send size of vector 

    for(int i =0; i< len; i++){

        size = (contours[i].size() * sizeof(int)) + 24; //byte amount to send and receive

        send(new_socket, &size, sizeof(int), 0);
        send(new_socket, &contours[i], size, 0);
    } 
}

vectorcontours={{3,6,8}，{7,24,64}，{87399}；
int len=3；
int size=0；
while（waitKey（10）！='q'）
{      
send（new_socket，&len，sizeof（int），0）；//发送向量的大小
对于（int i=0；i

客户：

vector< vector<int> >contours;
vector<int> lines;
int contoursize =0;
int size =0;

while(waitKey(100) != 'q'){

    read(sock,&contoursize, sizeof(int));
    contours.resize(contoursize);

    for(int i =0; i< contoursize; i++){
        read(sock, &size, sizeof(int));


         cout<<" size: "<<size<<endl;

        read(sock, &lines, size);
        contours[i]= lines;
    }
}

vector等高线；
矢量线；
int-contoursize=0；
int size=0；
while（waitKey（100）！='q'）{
读取（袜子和轮廓尺寸，尺寸（内部））；
轮廓。调整大小（轮廓大小）；
对于（int i=0；i<轮廓尺寸；i++）{
读取（sock和size，sizeof（int））；
使用
send（new_socket，&contours[i]，size，0）
可以在
contours[i]
中发送实际的
std:：vector
对象，而不发送其数据。
std:：vector
对象实际上只是指针和大小的包装器。并且不能通过网络发送指针

您需要发送每个向量的实际数据：

for (auto const& sub_vector : contours)
{
    // First send the number of elements
    uint32_t number_elements = sub_vector.size();
    send(new_socket, &number_elements, sizeof number_elements, 0);

    // Then send the actual data
    send(new_socket, sub_vector.data(), sub_vector.size() * sizeof sub_vector[0], 0);
}

[省略了错误检查，但您确实应该这样做。]

我还建议您不要使用像
int
这样的类型，因为它的大小实际上不是固定的。如果您想要无符号32位整数，请使用
uint32\u t
。当然，您可以在程序内部使用
int
，并将数据转换为可移植的固定大小类型进行传输，只要接收端可以这样做相反的转换


此外，我建议您也发送要发送的子向量的数量，以便接收方事先知道：

uint32_t number_vectors = contours.size();
send(new_socket, &number_vectors, sizeof number_vectors, 0);

for (...) { ... }

在接收端，您可以执行以下操作

// Receive the number of sub-vectors
uint32_t number_vectors;
recv(sock, &number_vectors, sizeof number_vectors, 0);

// Create the vectors
std::vector<std::vector<int>> contours(num_vectors);

// Read all sub-vectors
for (auto& sub_vector : contours)
{
    // Receive the amount of values
    uint32_t number_elements;
    recv(sock, &number_elements, sizeof number_elements, 0);

    // Create the sub-vector
    sub_vector = std::vector<int>(number_elements);

    // Receive the sub-vector data
    recv(sock, sub_vector.data(), sub_vector.size() * sizeof sub_vector[0], 0);
}

//接收子向量的数量
uint32个数字向量；
recv（sock和数字向量，数字向量的大小，0）；
//创建向量
std：：矢量轮廓（num_矢量）；
//读取所有子向量
用于（自动和子_矢量：等高线）
{
//接收值的数量
uint32\u t编号\u元素；
recv（sock和number_元素，number_元素的大小，0）；
//创建子向量
子向量=标准向量（元素数）；
//接收子向量数据
recv（sock，sub_vector.data（），sub_vector.size（）*sizeof sub_vector[0]，0）；
}

[注意：再次省略错误检查，但应该确实存在。]
使用
发送（新的\u套接字，&contours[i]，大小，0）
发送
等高线[i]中的实际
std:：vector
对象
，您不发送它的数据。
std:：vector
对象实际上只是指针和大小的包装器。您不能通过网络发送指针

您需要发送每个向量的实际数据：

for (auto const& sub_vector : contours)
{
    // First send the number of elements
    uint32_t number_elements = sub_vector.size();
    send(new_socket, &number_elements, sizeof number_elements, 0);

    // Then send the actual data
    send(new_socket, sub_vector.data(), sub_vector.size() * sizeof sub_vector[0], 0);
}

[省略了错误检查，但您确实应该这样做。]

我还建议您不要使用像
int
这样的类型，因为它的大小实际上不是固定的。如果您想要无符号32位整数，请使用
uint32\u t
。当然，您可以在程序内部使用
int
，并将数据转换为可移植的固定大小类型进行传输，只要接收端可以这样做相反的转换


此外，我建议您也发送要发送的子向量的数量，以便接收方事先知道：

uint32_t number_vectors = contours.size();
send(new_socket, &number_vectors, sizeof number_vectors, 0);

for (...) { ... }

在接收端，您可以执行以下操作

// Receive the number of sub-vectors
uint32_t number_vectors;
recv(sock, &number_vectors, sizeof number_vectors, 0);

// Create the vectors
std::vector<std::vector<int>> contours(num_vectors);

// Read all sub-vectors
for (auto& sub_vector : contours)
{
    // Receive the amount of values
    uint32_t number_elements;
    recv(sock, &number_elements, sizeof number_elements, 0);

    // Create the sub-vector
    sub_vector = std::vector<int>(number_elements);

    // Receive the sub-vector data
    recv(sock, sub_vector.data(), sub_vector.size() * sizeof sub_vector[0], 0);
}

//接收子向量的数量
uint32个数字向量；
recv（sock和数字向量，数字向量的大小，0）；
//创建向量
std：：矢量轮廓（num_矢量）；
//读取所有子向量
用于（自动和子_矢量：等高线）
{
//接收值的数量
uint32\u t编号\u元素；
recv（sock和number_元素，number_元素的大小，0）；
//创建子向量
子向量=标准向量（元素数）；
//接收子向量数据
recv（sock，sub_vector.data（），sub_vector.size（）*sizeof sub_vector[0]，0）；
}

[注意：再次省略错误检查，但应该确实存在。]
读取（sock，&lines，size）
-您正在覆盖
向量本身的结构，而不是读取它所包含的缓冲区。但是为什么不使用库呢？标准库没有提供任何适当的序列化机制，所以使用其他广泛使用的库是正确的。为什么是+24？而且您不能只读取随机数据i到一个对象。你必须发送内容并读入内容。这就是为什么它可能会爆炸
read（sock，&lines，size）
-您正在覆盖
向量本身的结构，而不是读取它所包含的缓冲区。但是为什么不使用库呢？标准库没有提供任何适当的序列化机制，所以使用其他广泛使用的库是正确的。为什么是+24？而且您不能只读取随机数据i你必须发送内容并读入内容。这就是它可能爆炸的原因