C++ Socket发送含std::string的自定义对象时段错误问题求解

直接用reinterpret_cast将包含std::string的自定义对象转为char*发送是错误的——std::string内部存储的是堆内存指针，接收端进程无法访问发送端的堆地址，因此访问或销毁对象时会触发段错误。正确的做法是序列化对象为连续的原始字节流，接收端再反序列化重建对象。

以下是完整实现示例：

1. 定义Message结构体 #

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

struct Message {
    int socket_id;       // 客户端/好友socket ID
    std::string format;  // 格式字段
    std::string content; // 消息内容字段
};

2. 序列化函数（将Message转为字节流） #

把对象拆解为「数值（转网络字节序）+ 字符串长度（转网络字节序）+ 字符串内容」的连续字节：

// 返回动态分配的字节数组，total_len输出总长度
char* serialize_message(const Message& msg, int& total_len) {
    const int socket_id_size = sizeof(int);
    const int format_len = msg.format.size();
    const int content_len = msg.content.size();

    // 计算总字节数：socket_id + 两个长度字段 + 两个字符串内容
    total_len = socket_id_size + sizeof(int) + format_len + sizeof(int) + content_len;
    char* buffer = new char[total_len];
    char* ptr = buffer;

    // 序列化socket_id（转网络字节序解决大小端问题）
    const int network_socket_id = htonl(msg.socket_id);
    memcpy(ptr, &network_socket_id, socket_id_size);
    ptr += socket_id_size;

    // 序列化format：先发送长度，再发送内容
    const int network_format_len = htonl(format_len);
    memcpy(ptr, &network_format_len, sizeof(int));
    ptr += sizeof(int);
    memcpy(ptr, msg.format.c_str(), format_len);
    ptr += format_len;

    // 序列化content：同上
    const int network_content_len = htonl(content_len);
    memcpy(ptr, &network_content_len, sizeof(int));
    ptr += sizeof(int);
    memcpy(ptr, msg.content.c_str(), content_len);

    return buffer;
}

3. 反序列化函数（从字节流重建Message） #

按序列化的逆顺序解析，将网络字节序转回主机字节序，再构造std::string：

// 从buffer中解析出Message，返回解析是否成功
bool deserialize_message(const char* buffer, int buffer_len, Message& msg) {
    // 最小长度检查：socket_id + 两个长度字段
    if (buffer_len < sizeof(int) * 3) {
        return false;
    }

    const char* ptr = buffer;

    // 解析socket_id
    int network_socket_id;
    memcpy(&network_socket_id, ptr, sizeof(int));
    msg.socket_id = ntohl(network_socket_id);
    ptr += sizeof(int);

    // 解析format
    int network_format_len;
    memcpy(&network_format_len, ptr, sizeof(int));
    const int format_len = ntohl(network_format_len);
    ptr += sizeof(int);
    if (ptr + format_len > buffer + buffer_len) {
        return false;
    }
    msg.format.assign(ptr, format_len); // 直接用内容构造string，避免无效指针
    ptr += format_len;

    // 解析content
    int network_content_len;
    memcpy(&network_content_len, ptr, sizeof(int));
    const int content_len = ntohl(network_content_len);
    ptr += sizeof(int);
    if (ptr + content_len > buffer + buffer_len) {
        return false;
    }
    msg.content.assign(ptr, content_len);

    return true;
}

4. 客户端发送逻辑 #

先发送消息总长度，再发送序列化后的字节流：

bool send_message(int sock_fd, const Message& msg) {
    int total_len;
    char* buffer = serialize_message(msg, total_len);
    if (!buffer) {
        return false;
    }

    // 先发送总长度，让服务器知道需要接收多少字节
    const int network_total_len = htonl(total_len);
    const ssize_t sent_len = send(sock_fd, &network_total_len, sizeof(int), 0);
    if (sent_len != sizeof(int)) {
        delete[] buffer;
        return false;
    }

    // 发送序列化后的消息内容
    const ssize_t content_sent_len = send(sock_fd, buffer, total_len, 0);
    delete[] buffer;
    return content_sent_len == total_len;
}

5. 服务器接收逻辑 #

先接收总长度，再分配对应大小的缓冲区接收内容，最后反序列化：

bool receive_message(int sock_fd, Message& msg) {
    // 接收消息总长度
    int network_total_len;
    const ssize_t len_recv = recv(sock_fd, &network_total_len, sizeof(int), 0);
    if (len_recv != sizeof(int)) {
        return false;
    }
    const int total_len = ntohl(network_total_len);

    // 分配缓冲区接收消息内容
    char* buffer = new char[total_len];
    const ssize_t content_recv_len = recv(sock_fd, buffer, total_len, 0);
    if (content_recv_len != total_len) {
        delete[] buffer;
        return false;
    }

    // 反序列化重建Message
    const bool success = deserialize_message(buffer, total_len, msg);
    delete[] buffer;
    return success;
}

关键注意事项 #

• 必须先发送总长度：因为字符串长度可变，服务器需要知道要接收的字节总数，避免截断或多读。
• 处理大小端问题：所有多字节数值（如int）必须用htonl/ntohl转换为网络字节序，确保跨平台传输正确性。
• 直接复制字符串内容：不要传递std::string对象本身或其内部指针，必须拷贝c_str()指向的实际字符数据。
• 内存管理：序列化时动态分配的缓冲区要记得释放，避免内存泄漏。

内容的提问来源于stack exchange，提问作者MediumCoder