一个 struct { char op; int x; int y; } 在 64 位 Linux 上 sizeof 是 12,不是 9;三个字段的偏移是 0、4、8,不是 0、1、5。如果把它整块 write 出去、对面按"op 占 1 字节,接着两个 int"来读,第一个 int 就会从偏移 1 开始取,读到的是一串错位的字节。填充字节(padding)、字段宽度、字节序,是手写序列化绕不开的三件事。
课件先给了两条路:空格分隔和 JSON
课件的 protocol.hpp 用条件编译切换两套实现。文本版把请求写成 "x op y":
/* Request::Serialize —— 成员函数,两种实现靠宏切换 */
bool Serialize(std::string *out)
{
#ifdef SelfDefine
*out = std::to_string(_data_x) + ProtSep + _oper + ProtSep + std::to_string(_data_y);
return true;
#else
Json::Value root;
root["datax"] = _data_x;
root["datay"] = _data_y;
root["oper"] = _oper;
Json::FastWriter writer;
*out = writer.write(root);
return true;
#endif
}反序列化文本版用 find 找第一个空格、rfind 找最后一个空格,中间剩下的当运算符,并要求它的长度恰好是 1。这套夹逼能扛住 -3 + 5,因为负号不影响空格位置;扛不住字段内容里出现空格——协议一旦加一个可以带空格的名字,夹出来的"运算符"就会变成 "world 3 +"。
这里还有两个容易忽略的失败方式。std::stoi 只解析"能解析的最长前缀",stoi("12abc") 返回 12 而不报错,所以"没抛异常"不等于"整串都是数字"。以及先赋值再校验的顺序问题:如果先把 _data_x 写进成员,再在解析 _data_y 时失败返回,对象就停在半更新状态,调用方拿到 false 也不知道哪些字段可信。先解析到临时变量、全部通过再提交,失败的解析不该留下痕迹。
这两种文本格式的共性是:字段的含义靠位置和分隔符约定,任何字段都不能自由包含分隔符。JSON 用转义绕开了这一点,代价是体积和解析开销。
回包是同一套思路的镜像:文本版写成 "result code" 两个数字,JSON 版是两个键;课件还配了一个 Factory 集中构造请求和回包,返回 shared_ptr,这样编解码的对称性只在一个地方维护。
memcpy 只负责搬运,不负责解释
memcpy 的语义是"拷贝若干字节",它不管这串字节是整数、浮点还是一段文本。真正决定对面能不能读懂的是字段的宽度和排布:
| 类型 | 常见宽度 | 能不能直接上线路 |
|---|---|---|
char | 1 | 符号性由实现决定,存数字别用它 |
short | 2 | 标准只保证至少 16 位 |
int | 4 | 常见平台都是 4 字节,但标准只保证至少 16 位 |
long | 4(Windows/ILP32)、8(Linux LP64) | 最不该出现在协议里 |
int32_t / uint32_t | 固定 | 用这个 |
同一份结构体,字段顺序一换,sizeof 和偏移都可能变。{ int x; int y; char op; } 在 64 位上是 12 字节:最后那个 char 后面还跟着 3 字节尾部填充,把整个结构体撑到 int 的对齐边界上。填充区里通常是未初始化的字节,整块发出去等于把栈上的残留内容漏到网络上。
所以手写的第一原则是逐字段写进缓冲区,宽度用定宽类型,偏移由代码显式算出来,绝不依赖 sizeof(struct)。
顺带分清两件事:把 buf + 5 强转成 int * 再解引用,在要求对齐的架构上是未定义行为;memcpy(&x, buf + 5, 4) 则是安全的,标准库会处理对齐。想从字节流里取一个整数,用后者,或者干脆逐字节拼。
字节序只在二进制格式里才是问题
文本长度和文本字段没有字节序问题:任何机器读到字符 '5' 都理解为 5。一旦把 int 原样写进字节流,就必须约定大小端。TCP/IP 的惯例是用大端(big-endian),htonl 把 32 位主机序转成网络序,htons 管 16 位,64 位没有对应的 htonll,得自己按字节写。
htonl 在小端机上是字节反转,在大端机上是恒等。这也意味着不要在 x86 上用 printf("%x", htonl(0x01020304)) 来"验证"它——打出来还是 0x01020304,只有把内存逐字节打出来才能看到 01 02 03 04。数值和它在内存里的排列是两回事。
下面这两个函数把大端写死在代码里,跨架构和跨语言都不需要再解释一遍,顺带也避免了 htonl 只管 32 位的尴尬:
#include <stdint.h>
static void put_u32be(uint8_t *p, uint32_t v)
{
p[0] = (uint8_t)(v >> 24);
p[1] = (uint8_t)(v >> 16);
p[2] = (uint8_t)(v >> 8);
p[3] = (uint8_t)v;
}
static uint32_t get_u32be(const uint8_t *p)
{
return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
((uint32_t)p[2] << 8) | (uint32_t)p[3];
}负数按补码写进去,读回来再转成 int32_t。标准规定"无符号值超出有符号范围"的转换是实现定义的,主流平台按补码处理,这也是绝大多数协议的做法。
变长字段、上限和校验
定长字段之外还需要变长字段,比如用户名、错误描述。变长字段的写法只有一个:在它前面放一个长度前缀,接收端按长度取,而不是按结束符找。strlen 在这里不能用——正文里可能合法地出现 \0,而 strlen 到那里就停了。长度算的也必须是字节数,一个 UTF-8 汉字占 3 字节,按"字符数"算会让接收端永远凑不齐。
长度前缀还必须配一个上限。没有上限时,对方声明一个天文数字,你的缓冲区永远填不满,这条连接就被一只报文占着,等于一次免费的资源耗尽。
课件把整条消息包成 长度\r\n正文\r\n,解码时先找第一个 \r\n,转出长度,再算"长度文本 + 2 + 正文 + 2"这个总字节数;不够就返回 false 等下一次读,够了就切出正文并把这一段从缓冲区删掉。中间态从 "l"、"len"、"len\r\n" 一直到 "len\r\nx op y\r\n",每一种都可能出现在缓冲区里,所以解码函数必须能被反复调用,而不是"读一次就解析一次"。
两个细节值得纠正。一是分隔符:课件前半用 \r\n,后半又改成 \n,两端照抄一半就会永远解析不出报文。二是返回值:bool 把"数据还不够"和"这条报文非法"混成一个 false,前者该继续等,后者该断开,用三态枚举才分得清。
校验分三层:魔数拒绝错位的字节流,长度拒绝截断,校验和(比如 CRC32)拒绝内容在传输或内存里被改坏。CRC32 只能发现意外损坏,不能防篡改——需要防篡改时得上 MAC 或签名,那是另一个层面的问题。
一份带边界检查的二进制编解码
报文头 12 字节:魔数 4、版本 1、类型 1、预留 2、正文长度 4;正文 9 字节:x、y 各 4 字节,运算码 1 字节。
/* wire.c —— gcc -std=c11 -Wall -Wextra wire.c -o wire */
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#define MAGIC 0x43414c43u /* "CALC" */
#define VERSION 1u
#define HEADER 12u
#define BODY 9u
struct request { int32_t x; int32_t y; uint8_t op; };
static void put_u32be(uint8_t *p, uint32_t v)
{
p[0] = (uint8_t)(v >> 24);
p[1] = (uint8_t)(v >> 16);
p[2] = (uint8_t)(v >> 8);
p[3] = (uint8_t)v;
}
static uint32_t get_u32be(const uint8_t *p)
{
return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
((uint32_t)p[2] << 8) | (uint32_t)p[3];
}
/* 成功返回整条报文的字节数;容量不足返回 0 */
size_t pack_request(const struct request *r, uint8_t *out, size_t cap)
{
if (cap < HEADER + BODY) return 0;
put_u32be(out + 0, MAGIC);
out[4] = (uint8_t)VERSION;
out[5] = 0; /* 类型:0 = 请求 */
out[6] = 0; /* 预留字段显式写 0 */
out[7] = 0; /* 不留未初始化字节 */
put_u32be(out + 8, BODY);
put_u32be(out + 12, (uint32_t)r->x);
put_u32be(out + 16, (uint32_t)r->y);
out[20] = r->op;
return HEADER + BODY;
}
/* 成功返回 1;任何一项校验不过返回 0 */
int unpack_request(const uint8_t *in, size_t n, struct request *r)
{
if (n < HEADER) return 0;
if (get_u32be(in + 0) != MAGIC) return 0;
if (in[4] != VERSION) return 0;
if (in[5] != 0) return 0;
if (get_u32be(in + 8) != BODY) return 0; /* 这个类型的正文长度是固定的 */
if (n < HEADER + BODY) return 0;
r->x = (int32_t)get_u32be(in + 12);
r->y = (int32_t)get_u32be(in + 16);
r->op = in[20];
switch (r->op) {
case '+': case '-': case '*': case '/': case '%':
return 1;
default:
return 0;
}
}
int main(void)
{
struct request a = { 7, 3, '+' };
struct request b;
uint8_t wire[64];
size_t n = pack_request(&a, wire, sizeof(wire));
if (n == 0 || !unpack_request(wire, n, &b)) {
fprintf(stderr, "round-trip failed\n");
return 1;
}
printf("%d %c %d\n", b.x, b.op, b.y); /* 7 + 3 */
return 0;
}写完这段,再回头看一眼文本版和 JSON 版,会发现三者做的是同一件事:把字段按固定规则摆进一段连续内存。文本版把规则写在分隔符上,JSON 把规则写在语法里,二进制版把规则写进偏移和宽度。手写一遍的意义在于知道每一层在省什么、又在赌什么;真要上线,跨语言、要长期演进的场景交给 Protobuf 这类 schema 驱动的方案,字段顺序、宽度、兼容性都由工具保证,不用靠注释提醒同事"两边记得一起改"。
还没有评论 — 第一条由你来留。