应用层自定义协议与序列化：设计一个端到端的协议

Calculate.hpp    Protocol.hpp    Socket.hpp
Daemon.hpp       Makefile
TcpServerMain.cc TcpClientMain.cc

// socket.hpp
#pragma once                                // 防止头文件被重复包含
#include <iostream>                          // C++ 标准输入输出流（便于调试打印）
#include <string>                            // std::string
#include <cstring>                           // memset、strerror
#include <sys/types.h>                       // socket 相关的底层类型
#include <sys/socket.h>                      // socket/bind/listen/accept/connect/recv/send/close
#include <netinet/in.h>                      // struct sockaddr_in
#include <arpa/inet.h>                       // htons/htonl/ntohs/ntohl/inet_addr/inet_ntoa
#include <unistd.h>                          // close
 
// 把"socket 协议族地址结构"通用地转成 sockaddr* 的简化宏
// sockaddr_in 和 sockaddr 内存布局兼容，传递前需要强转类型
#define Convert(addrptr) ((struct sockaddr *)addrptr)
 
namespace Net_Work
{
    const int defaultsockfd = -1;            // 表示"无效 fd"的默认值
    const int backlog = 5;                   // listen 的等待连接队列长度
 
    enum { SocketError = 1, BindError, ListenError };  // 各类失败对应的退出码
 
    // 基类：Socket 接口。定义"连招"式的流程骨架，具体动作交给子类实现
    class Socket
    {
    public:
        virtual ~Socket() {}                              // 虚析构，保证多态删除正确
 
        // ---- 纯虚函数：由派生类实现的具体原子操作 ----
        virtual void CreateSocketOrDie() = 0;             // 创建一个 socket
        virtual void BindSocketOrDie(uint16_t port) = 0;  // 绑定端口
        virtual void ListenSocketOrDie(int backlog) = 0;  // 进入监听
        virtual Socket *AcceptConnection(std::string *peerip, uint16_t *peerport) = 0; // 接受连接
        virtual bool ConnectServer(std::string &serverip, uint16_t serverport) = 0;   // 主动连接
        virtual int GetSockFd() = 0;                      // 拿到底层 fd
        virtual void SetSockFd(int sockfd) = 0;           // 设置底层 fd
        virtual void CloseSocket() = 0;                   // 关闭 socket
        virtual bool Recv(std::string *buffer, int size) = 0; // 读取一次数据
        virtual void Send(std::string &send_str) = 0;     // 发送字符串
 
    public:
        // 模板方法：把"监听端"的三板斧串起来，子类只需各自实现
        void BuildListenSocketMethod(uint16_t port, int backlog)
        {
            CreateSocketOrDie();     // 第 1 步：创建
            BindSocketOrDie(port);   // 第 2 步：绑定端口
            ListenSocketOrDie(backlog); // 第 3 步：监听
        }
 
        // 模板方法：把"客户端"的建连两步串起来
        bool BuildConnectSocketMethod(std::string &serverip, uint16_t serverport)
        {
            CreateSocketOrDie();                      // 第 1 步：创建
            return ConnectServer(serverip, serverport); // 第 2 步：连接
        }
 
        // 模板方法：accept 返回的已经是一个已建立的连接 fd，直接"接管"即可
        void BuildNormalSocketMethod(int sockfd)
        {
            SetSockFd(sockfd);
        }
    };
 
    // 派生类：基于 TCP 的具体实现
    class TcpSocket : public Socket
    {
    public:
        TcpSocket(int sockfd = defaultsockfd)
            : _sockfd(sockfd)
        {
        }
 
        ~TcpSocket()
        {
            CloseSocket();          // 析构时顺手关掉 fd，防止泄漏
        }
 
        // 创建一个 TCP 流式 socket
        void CreateSocketOrDie() override
        {
            _sockfd = ::socket(AF_INET, SOCK_STREAM, 0); // AF_INET:IPv4,SOCK_STREAM:可靠字节流
            if (_sockfd < 0)                             // 创建失败
                exit(SocketError);
        }
 
        // 绑定一个监听端口
        void BindSocketOrDie(uint16_t port) override
        {
            struct sockaddr_in local;                   // 本地地址结构
            memset(&local, 0, sizeof(local));           // 清零，避免脏数据
            local.sin_family = AF_INET;                 // IPv4 协议族
            local.sin_addr.s_addr = INADDR_ANY;         // 绑定所有网卡地址
            local.sin_port = htons(port);               // 端口转成网络字节序
            int n = ::bind(_sockfd, Convert(&local), sizeof(local));
            if (n < 0)                                  // 绑定失败
                exit(BindError);
        }
 
        // 进入监听状态
        void ListenSocketOrDie(int backlog) override
        {
            int n = ::listen(_sockfd, backlog);          // backlog 指定连接队列长度
            if (n < 0)                                   // 监听失败
                exit(ListenError);
        }
 
        // 接受一个连接，把对端 ip/port 填出来，并返回一个专门和它通信的新 socket
        Socket *AcceptConnection(std::string *peerip, uint16_t *peerport) override
        {
            struct sockaddr_in peer;                    // 对端地址
            socklen_t len = sizeof(peer);               // 地址结构长度（输入输出参数）
            int newsockfd = ::accept(_sockfd, Convert(&peer), &len);
            if (newsockfd < 0)
                return nullptr;                         // 失败返回空指针
            *peerport = ntohs(peer.sin_port);           // 对端端口转回主机字节序
            *peerip = inet_ntoa(peer.sin_addr);         // 对端 IP 转成可读字符串
            Socket *s = new TcpSocket(newsockfd);       // 用它的 fd 包一个新对象
            return s;
        }
 
        // 作为客户端，主动连接服务器
        bool ConnectServer(std::string &serverip, uint16_t serverport) override
        {
            struct sockaddr_in server;                  // 服务器地址结构
            memset(&server, 0, sizeof(server));
            server.sin_family = AF_INET;                // IPv4
            server.sin_addr.s_addr = inet_addr(serverip.c_str()); // 文本 IP 转二进制
            server.sin_port = htons(serverport);        // 端口网络字节序
            int n = ::connect(_sockfd, Convert(&server), sizeof(server));
            return n == 0;                              // n==0 表示连接成功
        }
 
        int GetSockFd() override { return _sockfd; }
        void SetSockFd(int sockfd) override { _sockfd = sockfd; }
 
        void CloseSocket() override
        {
            if (_sockfd > defaultsockfd)                // fd 有效才关闭
                ::close(_sockfd);
        }
 
        // 读取一次数据，追加到 buffer 尾部。关键点：可能要读多次才积累成完整报文
        bool Recv(std::string *buffer, int size) override
        {
            char inbuffer[size];                        // 临时缓冲区（VLA，需编译器支持）
            ssize_t n = recv(_sockfd, inbuffer, size - 1, 0); // 读最多 size-1 字节
            if (n > 0)
            {
                inbuffer[n] = 0;                        // 手动补字符串结束符
                *buffer += inbuffer;                    // 故意"拼接"——留到协议层去切分
                return true;
            }
            else
            {
                return false;                           // n==0 对端关闭；n<0 出错
            }
        }
 
        void Send(std::string &send_str) override
        {
            // 简单的发送：这里不处理"一次没发完"的情况（完整版本可加循环发送）
            send(_sockfd, send_str.c_str(), send_str.size(), 0);
        }
 
    private:
        int _sockfd;                                    // 底层的文件描述符
    };
}

// Protocol.hpp 中的协议骨架（先看结构定义）
class Request   // 客户端的请求
{
private:
    int _data_x;   // 第一个加数
    int _data_y;   // 第二个加数
    char _oper;    // 运算符：+ - * / %
    // 报文的自描述字段：约定一次完整报文的格式为 "len\r\nx op y\r\n"
    // 其中 \r\n 不属于报文的数据部分，只是我们约定的分隔符
};
 
class Response  // 服务器的响应
{
private:
    int _result;   // 运算结果
    int _code;     // 运算状态码（0 表示成功，非 0 表示出错，如除零）
    // 报文格式： "len\r\nresult code\r\n"
};

# Ubuntu / Debian 系
sudo apt-get install libjsoncpp-dev
 
# CentOS / RHEL 系
sudo yum install jsoncpp-devel

g++ -std=c++17 mycode.cc -o myapp -ljsoncpp

// json_serialize_demo.cc —— 三种序列化写法对比
#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>   // jsoncpp 统一头文件，路径见上文说明
 
int main()
{
    Json::Value root;            // 一个用于装 JSON 数据的容器
    root["name"] = "joe";        // 塞入键值对：name -> "joe"
    root["sex"] = "男";          // 中文也能存，JSON 底层是 UTF-8
    root["age"]  = 30;           // 数字类型直接就能塞进去
 
    // 写法 1：toStyledString()。输出带缩进和换行的"美化"格式，方便人读/调试
    std::string styled = root.toStyledString();
    std::cout << "=== toStyledString ===" << std::endl;
    std::cout << styled;
 
    // 写法 2：StreamWriter。自由度最高，可定制缩进/分隔符（这里演示基本用法）
    Json::StreamWriterBuilder wbuilder;              // 一个 Writer 工场
    std::unique_ptr<Json::StreamWriter> writer(wbuilder.newStreamWriter()); // 创一个 Writer
    std::ostringstream ss;                           // 把输出接到字符串流里
    writer->write(root, &ss);                        // 写入流
    std::cout << "=== StreamWriter ===" << std::endl;
    std::cout << ss.str();
 
    // 写法 3：FastWriter。速度最快，紧凑无缩进无多余换行，适合线上传输省带宽
    Json::FastWriter fwriter;
    std::string fast = fwriter.write(root);
    std::cout << "=== FastWriter ===" << std::endl;
    std::cout << fast;
    return 0;
}

{
   "age" : 30,
   "name" : "joe",
   "sex" : "男"
}
{ "age" : 30, "name" : "joe", "sex" : "男" }
{"age":30,"name":"joe","sex":"男"}

// json_deserialize_demo.cc —— 反序列化示例
#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>
 
int main()
{
    // 一段 JSON 字符串（注意字符串里的引号要转义）
    std::string json_string = "{\"name\":\"张三\", \"age\":30, \"city\":\"北京\"}";
 
    Json::Reader reader;                 // 解析器
    Json::Value root;                    // 解析出来的值会放进这里
 
    bool ok = reader.parse(json_string, root);  // 核心：把字符串解析进 root
    if (!ok)
    {
        // 解析失败：打印详细错误信息和出错位置，强烈建议每个 parse 都这样处理
        std::cout << "Failed to parse JSON: "
                  << reader.getFormattedErrorMessages() << std::endl;
        return 1;
    }
 
    // 从 root 里按键取值，并用 asXxx() 转成希望的类型
    std::string name = root["name"].asString();
    int age = root["age"].asInt();
    std::string city = root["city"].asString();
 
    std::cout << "Name: " << name << std::endl;
    std::cout << "Age: " << age << std::endl;
    std::cout << "City: " << city << std::endl;
    return 0;
}

// Protocol.hpp —— 协议层的完整实现
#pragma once
#include <iostream>                 // 调试打印
#include <memory>                   // std::shared_ptr / make_shared
#include <string>
#include <cassert>                  // assert，防御式检查用
#include <jsoncpp/json/json.h>      // jsoncpp 序列化库
 
namespace Protocol
{
    // 分隔符约定：字段之间的空格、一行报文内部的换行分隔符
    const std::string ProtSep = " ";
    const std::string LineBreakSep = "\r\n";   // 注意是 CRLF 两个字符
 
    // -----------------------------------------------------------
    // 一、报文编解码：解决"粘包"
    // 我们的线上报文格式约定为：
    //            "len\r\n" + 真正的数据 + "\r\n"
    // 即：长度字段 + 分隔符 + 数据 + 结束分隔符
    // \r\n 不属于报文的数据部分，只是我们约定的边界标记。
    // -----------------------------------------------------------
 
    // 编码：给一段"已经是字符串的报文数据"加上"长度前缀 + 分隔符"，打包成可上线的报文
    std::string Encode(const std::string &message)
    {
        std::string len = std::to_string(message.size());   // 用十进制文本表示长度
        std::string package = len + LineBreakSep + message + LineBreakSep; // 拼装
        return package;
    }
 
    // 解码：从"可能包含多段报文"的字节流里，尝试从头部切出一段完整报文。
    // 若头部凑不齐一条完整报文则返回 false；切成功则返回 true 并把数据填进 message。
    bool Decode(std::string &package, std::string *message)
    {
        // 第 1 步：找第一个 \r\n，它把"长度"和"数据"隔开
        auto pos = package.find(LineBreakSep);
        if (pos == std::string::npos)   // 连第一个分隔符都没找到 => 数据还不全
            return false;
 
        // 第 2 步：长度字段 = 开头到第一个 \r\n 之间那段文本
        std::string lens = package.substr(0, pos);
        int messagelen = std::stoi(lens);        // 把它转成整数（ASCII -> int）
 
        // 第 3 步：算这条完整报文总共占多少字节
        //        = "长度数字本身的字符数" + 数据长度 + 2 个 \r\n 的大小
        int total = lens.size() + messagelen + 2 * LineBreakSep.size();
 
        // 第 4 步：完整性校验 —— 只有积累了够 total 个字节，才可能是一条完整报文
        if ((int)package.size() < total)
            return false;
 
        // 第 5 步：此时 package 头部必定已经有一条完整报文，把它抠出来
        *message = package.substr(pos + LineBreakSep.size(), messagelen);
 
        // 第 6 步：把已消费的 total 字节从缓冲区头部删掉，剩下的留给下一次
        package.erase(0, total);
        return true;
    }
 
    // -----------------------------------------------------------
    // 二、请求与响应：结构的序列化 / 反序列化
    // -----------------------------------------------------------
 
    // 客户端请求
    class Request
    {
    public:
        Request() : _data_x(0), _data_y(0), _oper(0) {}   // 默认构造
        Request(int x, int y, char op) : _data_x(x), _data_y(y), _oper(op) {}
 
        // 序列化：把结构体 -> JSON 字符串
        bool Serialize(std::string *out)
        {
            Json::Value root;
            root["datax"] = _data_x;    // 塞入加数 x
            root["datay"] = _data_y;    // 塞入加数 y
            root["oper"]  = _oper;      // 注意：char 会被 json 当作整型（存的是 ASCII 码）
            Json::FastWriter writer;    // 用最省带宽的写法
            *out = writer.write(root);  // 输出 JSON 字符串
            return true;
        }
 
        // 反序列化：把 JSON 字符串 -> 结构体
        bool Deserialize(std::string &in)
        {
            Json::Value root;
            Json::Reader reader;
            bool res = reader.parse(in, root);   // 解析；失败时 res 为 false
            if (res)
            {
                _data_x = root["datax"].asInt(); // 按键取回
                _data_y = root["datay"].asInt();
                _oper = root["oper"].asInt();    // 取回的是 ASCII 码，拷进 char
            }
            return res;
        }
 
        // 调试：打印结构体内容，方便观察反序列化是否成功
        void Debug()
        {
            std::cout << "_data_x: " << _data_x << std::endl;
            std::cout << "_data_y: " << _data_y << std::endl;
            std::cout << "_oper(int): " << int(_oper) << std::endl;
        }
 
        int GetX() { return _data_x; }
        int GetY() { return _data_y; }
        char GetOper() { return _oper; }
 
    private:
        int _data_x;   // 第一个加数
        int _data_y;   // 第二个加数
        char _oper;    // 运算符
    };
 
    // 服务器响应
    class Response
    {
    public:
        Response() : _result(0), _code(0) {}
        Response(int result, int code) : _result(result), _code(code) {}
 
        bool Serialize(std::string *out)
        {
            Json::Value root;
            root["result"] = _result;   // 运算结果
            root["code"]   = _code;     // 状态码
            Json::FastWriter writer;
            *out = writer.write(root);
            return true;
        }
 
        bool Deserialize(std::string &in)
        {
            Json::Value root;
            Json::Reader reader;
            bool res = reader.parse(in, root);
            if (res)
            {
                _result = root["result"].asInt();
                _code   = root["code"].asInt();
            }
            return res;
        }
 
        void SetResult(int res) { _result = res; }
        void SetCode(int code)   { _code = code; }
        int GetResult() { return _result; }
        int GetCode()   { return _code; }
 
    private:
        int _result;   // 运算结果
        int _code;     // 运算状态（0 成功，非 0 出错）
    };
 
    // 简单的工厂：统一创建对象，未来替换实现时不用改调用方
    class Factory
    {
    public:
        std::shared_ptr<Request> BuildRequest()
        {
            return std::make_shared<Request>();
        }
        std::shared_ptr<Request> BuildRequest(int x, int y, char op)
        {
            return std::make_shared<Request>(x, y, op);
        }
        std::shared_ptr<Response> BuildResponse()
        {
            return std::make_shared<Response>();
        }
        std::shared_ptr<Response> BuildResponse(int result, int code)
        {
            return std::make_shared<Response>(result, code);
        }
    };
}

len\r\nx op y\r\nlen\r\nx op y\r\nlen\r\n x op y...

服务端 / 客户端之间，每一条完整报文的格式：
   "len\r\n"   +   "数据正文"   +   "\r\n"
   ↑ 长度字段     ↑ 报文内容(JSON)   ↑ 结束分隔符
 
例如一条"1+2"请求的报文为：
   "4\r\n{\"datax\":1,\"oper\":43,\"datay\":2}\r\n"

// Calculate.hpp —— 业务逻辑：真正的"服务器上帝视角"计算
#pragma once
#include <cstdint>   // 不一定要用，这里只是示意习惯
 
namespace Calc
{
    // 返回计算结果；出错时把错误码填到 code（0 表示成功）
    int Compute(int x, int y, char oper, int *code)
    {
        switch (oper)
        {
        case '+':
            *code = 0;
            return x + y;
        case '-':
            *code = 0;
            return x - y;
        case '*':
            *code = 0;
            return x * y;
        case '/':
            if (y == 0)        // 除零：没法算
            {
                *code = 1;      // 错误码 1 表示除零
                return 0;
            }
            *code = 0;
            return x / y;
        case '%':
            if (y == 0)        // 取模除零同理
            {
                *code = 1;
                return 0;
            }
            *code = 0;
            return x % y;
        default:
            *code = 2;          // 错误码 2 表示非法运算符
            return 0;
        }
    }
}

// TcpServerMain.cc —— 服务器：监听，接受一个连接，循环处理请求
#include "Socket.hpp"
#include "Protocol.hpp"
#include "Calculate.hpp"
#include <iostream>
#include <string>
 
using namespace Net_Work;
 
int main()
{
    // 1. 创建监听 socket
    TcpSocket listen_sock;
    uint16_t port = 8888;                    // 监听端口
    listen_sock.BuildListenSocketMethod(port, backlog);  // 创建 + 绑定 + 监听
 
    std::cout << "server listening on port " << port << std::endl;
 
    // 2. 接受一个客户端连接（单连接版。想支撑多个客户端，请用多路转接，这里不展开）
    std::string peerip;
    uint16_t peerport = 0;
    // accept 返回的是一个已经能直接收发数据的新 socket
    Socket *newsock = listen_sock.AcceptConnection(&peerip, &peerport);
    if (newsock == nullptr)
    {
        std::cerr << "accept failed" << std::endl;
        return 1;
    }
    std::cout << "client connected: " << peerip << ":" << peerport << std::endl;
 
    // 3. 维护一个"积累缓冲区"：解决"一次 recv 读不到完整报文"的核心
    std::string recv_buffer;
 
    // 4. 主循环：循环读 -> 切分 -> 处理
    while (true)
    {
        // 4.1 读一次原始字节，追加进积累缓冲区
        if (newsock->Recv(&recv_buffer, 1024) == false)
        {
            // Recv 返回 false：对端关闭或出错，结束连接
            std::cout << "client closed or error, exit" << std::endl;
            break;
        }
 
        // 4.2 反复 Decode：一次读到的可能在缓冲里积累了多条完整报文
        std::string message;
        while (Protocol::Decode(recv_buffer, &message))
        {
            // 4.2.1 反序列化：JSON 字符串 -> Request 对象
            Protocol::Request req;
            if (!req.Deserialize(message))
            {
                std::cerr << "bad request json, skip" << std::endl;
                continue;            // 对端发来坏数据，跳过这一条，不崩
            }
 
            // 4.2.2 业务计算
            int code = 0;
            int result = Calc::Compute(req.GetX(), req.GetY(), req.GetOper(), &code);
 
            // 4.2.3 构造响应对象并序列化成 JSON 字符串
            Protocol::Response resp(result, code);
            std::string json;
            resp.Serialize(&json);
 
            // 4.2.4 编码：给 JSON 串加上"长度前缀 + 分隔符"，变成可上线的一条报文
            std::string package = Protocol::Encode(json);
 
            // 4.2.5 发送回客户端
            newsock->Send(package);
            std::cout << "ans: " << req.GetX() << " " << req.GetOper()
                      << " " << req.GetY() << " = " << result
                      << " (code=" << code << ")" << std::endl;
        }
    }
 
    // 5. 善后
    newsock->CloseSocket();
    listen_sock.CloseSocket();
    return 0;
}

// TcpClientMain.cc —— 客户端：连接服务器，发送一批请求，同步收结果
#include "Socket.hpp"
#include "Protocol.hpp"
#include <iostream>
#include <string>
#include <unistd.h>   // usleep
 
using namespace Net_Work;
 
int main()
{
    // 1. 创建客户端 socket 并连上服务器
    TcpSocket client;
    std::string serverip = "127.0.0.1";   // 本地回环，可改成远程 IP
    uint16_t port = 8888;
    if (!client.BuildConnectSocketMethod(serverip, port))
    {
        std::cerr << "connect failed" << std::endl;
        return 1;
    }
    std::cout << "connected to " << serverip << ":" << port << std::endl;
 
    // 2. 构造一批要发送的 (x, y, op)
    struct Task { int x; int y; char op; };
    Task tasks[] = {
        {1, 2, '+'},
        {7, 3, '-'},
        {6, 7, '*'},
        {20, 4, '/'},
        {9, 2, '%'},
        {8, 0, '/'},   // 故意触发一次除零，看服务器的错误码
    };
 
    std::string recv_buffer;    // 客户端侧的积累缓冲区，同样要处理粘包
 
    // 3. 循环发送请求、回收响应
    for (auto &t : tasks)
    {
        // 3.1 构造 Request 并序列化
        Protocol::Request req(t.x, t.y, t.op);
        std::string request_json;
        req.Serialize(&request_json);
 
        // 3.2 编码（加长度前缀 + 分隔符）
        std::string package = Protocol::Encode(request_json);
        client.Send(package);
 
        // 3.3 读响应。注意：一次 Recv 可能读多/读少，必须靠 Decode 循环切
        bool got = false;
        while (!got)
        {
            if (client.Recv(&recv_buffer, 1024) == false)
            {
                std::cerr << "connection closed by server" << std::endl;
                return 1;
            }
            std::string response_json;
            while (Protocol::Decode(recv_buffer, &response_json))
            {
                Protocol::Response resp;
                resp.Deserialize(response_json);
                std::cout << t.x << " " << t.op << " " << t.y
                          << " = " << resp.GetResult()
                          << " (code=" << resp.GetCode() << ")" << std::endl;
                got = true;   // 本轮任务已得到响应
            }
        }
        usleep(200000);   // 稍微停顿看清结果
    }
    return 0;
}

# 两个入口分别编译；都要链 jsoncpp
g++ -std=c++17 TcpServerMain.cc -o server -ljsoncpp
g++ -std=c++17 TcpClientMain.cc -o client -ljsoncpp
 
# 先开一个终端跑服务器，再开另一个终端跑客户端
./server
./client

// 服务器
server listening on port 8888
client connected: 127.0.0.1:52345
ans: 1 + 2 = 3 (code=0)
ans: 7 - 3 = 4 (code=0)
ans: 6 * 7 = 42 (code=0)
ans: 20 / 4 = 5 (code=0)
ans: 9 % 2 = 1 (code=0)
ans: 8 / 0 = 0 (code=1)
 
// 客户端
connected to 127.0.0.1:8888
1 + 2 = 3 (code=0)
7 - 3 = 4 (code=0)
6 * 7 = 42 (code=0)
20 / 4 = 5 (code=0)
9 % 2 = 1 (code=0)
8 / 0 = 0 (code=1)

| 包头(Header) | 长度(Length) | 负载(Payload) |

大端内存:  01 02 03 04   (高字节在前)
小端内存:  04 03 02 01   (低字节在前)

#include <arpa/inet.h>
 
uint32_t host_val = 1000;              // 我本机（小端）里的值
uint32_t net_val  = htonl(host_val);   // 转成网络字节序（大端）再上网络
uint32_t back   = ntohl(net_val);      // 对端收到网络序后转回本机序
// back 一定等于 1000

struct S {
    char c;     // 偏移 0
    int  i;     // 编译器会把它对齐到 4 字节边界 => 偏移变成 4，中间空出 3 字节
    char d;     // 偏移 8
};
// sizeof(S) 可能是 12，而不是 1+4+1=6

// 1 字节对齐：成员之间不再自动插填充，结构体按声明的顺序紧挨着排
#pragma pack(push, 1)
struct BinaryRequest {
    int32_t x;     // 第一个加数
    int32_t y;     // 第二个加数
    char    oper;  // 运算符
};
#pragma pack(pop)
// 现在 sizeof(BinaryRequest) == 9 （4+4+1），可预期、可控

// binary_protocol_demo.cc —— 二进制协议：包头+长度+负载 + 网络字节序 + 1字节对齐
#include <iostream>
#include <cstring>      // memcpy
#include <cstdint>      // uint8_t/uint32_t
#include <arpa/inet.h>  // htonl/ntohl
#include <string>
 
// 1 字节对齐：去掉编译器的自动填充，让结构体按声明的顺序紧凑排布
#pragma pack(push, 1)
 
// 包头：固定 8 字节。magic 用来校验"这确实是我们的协议"，len 是负载字节数
struct PacketHeader {
    uint32_t magic;    // 魔数，比如 0xCAFEBABE，用于快速识别是不是我们的报文
    uint32_t len;      // 负载区长度，用网络字节序存
};
 
// 负载：我们要传输的"请求"数据。打包/解包时对 x、y 做端序转换
struct BinaryRequest {
    int32_t  x;        // 第一个加数
    int32_t  y;        // 第二个加数
    uint8_t  oper;     // 运算符的 ASCII 码
};
 
#pragma pack(pop)
 
// 把一个"包头 + 负载"结构体编码成一串二进制字节（负责加入网络字节序）
std::string Pack(const PacketHeader &hdr, const BinaryRequest &req)
{
    // 组装包头：正确转端序
    PacketHeader nh = hdr;
    nh.magic = hdr.magic;              // 魔数通常直接用常量，也可不转端序（见文末说明）
    nh.len   = htonl(hdr.len);         // 长度转成网络字节序后输出
 
    // 组装负载：把整数转成网络字节序
    BinaryRequest nr = req;
    nr.x = htonl(req.x);
    nr.y = htonl(req.y);
 
    // 按固定字节布局拷贝进一个字节串
    std::string out;
    out.resize(sizeof(PacketHeader) + sizeof(BinaryRequest));
    std::memcpy(&out[0],                 &nh, sizeof(PacketHeader));   // 先放飞包头
    std::memcpy(&out[sizeof(PacketHeader)], &nr, sizeof(BinaryRequest)); // 再放飞负载
    return out;
}
 
// 还原：把一坨字节解成 (包头, 负载)，并把端序转回主机序
void Unpack(const std::string &raw, PacketHeader *hdr, BinaryRequest *req)
{
    // 先取包头
    std::memcpy(hdr, &raw[0], sizeof(PacketHeader));
    // 再取负载（包头后面接着）
    std::memcpy(req, &raw[sizeof(PacketHeader)], sizeof(BinaryRequest));
 
    // 把网络字节序还原回主机字节序
    hdr->len = ntohl(hdr->len);   // 长度还原
    req->x   = ntohl(req->x);     // x 还原
    req->y   = ntohl(req->y);     // y 还原
}
 
int main()
{
    // 构造一份请求：6 + 7 = ?
    BinaryRequest req;
    req.x = 6;
    req.y = 7;
    req.oper = '+';
 
    // 手工写一份对应的包头
    PacketHeader hdr;
    hdr.magic = 0xCAFEBABE;                       // 自定义魔数
    hdr.len   = sizeof(BinaryRequest);            // 负载长度 = 9
 
    // 打包成字节，模拟"发到网络"
    std::string wire = Pack(hdr, req);
    std::cout << "wire size = " << wire.size() << " (应= 8+9=" << (sizeof(PacketHeader)+sizeof(BinaryRequest)) << ")" << std::endl;
 
    // 接收端解包
    PacketHeader rh;
    BinaryRequest rr;
    Unpack(wire, &rh, &rr);
 
    std::cout << "magic = " << std::hex << rh.magic << std::dec << std::endl;
    std::cout << "len   = " << rh.len << "  (应= 9)" << std::endl;
    std::cout << "x     = " << rr.x << std::endl;
    std::cout << "y     = " << rr.y << std::endl;
    std::cout << "oper  = " << char(rr.oper) << std::endl;
    return 0;
}

g++ -std=c++17 binary_protocol_demo.cc -o binproto
./binproto
# 期望输出：x=6  y=7  oper=+   len=9   wire size=17

"protocol_code\r\n" + "len\r\n" + 数据 + "\r\n"