7.4. Serialization：如何封装数据
要将文字数据透过网路传送很简单，你已经知道了，不 过如果你想要送一些 ＂二进制＂ 的数据，如 int 或 float，会发生什麽事情呢？这里有一些选择。
1. 将数字转换为文字，使用如 sprintf() 的函数，接着传送文字。接收者会使用如 strtol() 函数解析文字，并转换为数字。
2. 直接以原始数据传送，将指向数据的指针传递给 send()。
3. 将数字编码（encode）为可移植的二进制格式，接收者会将它译码（decode）。
先睹为快！只在今晚！
［序幕］
Beej 说：＂我偏好上面的第三个方法！＂
［结束］
（在我热切开始本章节之前，我应该要跟你说有现成的程序库可以做这件事情，而要自制个可移植及无错误的作品会是相当大的挑战。所以在决定要自己实作这部分时，可以先四处看看，并做完你的家庭作业。我在这里引用些类似这个作品的有趣的资料。）
实际上，上面全部的方法都有它们的缺点与优点，但是如我所述，通常我偏好第三个方法。首先，咱们先谈谈另外两个的优缺点。
第一个方法，在传送以前先将数字编码为文字，优点是你可以很容易打印出及读取来自网路的数据。有时，人类易读的协定比较适用於频带不敏感（non-bandwidth-intensive）的情况，例如：Internet Relay Chat（IRC）[27]。然而，缺点是转换耗时，且总是需要比原本的数字使用更多的空间。
第二个方法：传送原 始数据（raw data），这个方法相当简单［但是危险！］：只要将数据指针提供给 send()。
double d = 3490.15926535;
send(s, &d, sizeof d, 0); /* 危险，不具可移植性！ */
接收者类似这 样接收：
double d;
recv(s, &d, sizeof d, 0); /* 危险，不具可移植性！ */
快速又简单，那有什麽不好的呢？
好的，事实证明不是全部的架构都能表示 double［或 int］。［嘿！或许你不需要可移植性，在这样的情况下这个方法很好，而且快速。］
当封装整数型别时，我们已经知道 htons() 这类的函数如何 透过将数字转换为 Network Byte Order（网路字节顺序），来让东西可以移植。毫无疑问地，没有类似的函数可以供 float 型别使用，全部的希望都落空了吗？
别怕！［你有担心了一会儿吗？没有吗？一点都没有吗？］
我们可以做件事情：我们可以将数据封装为接收者已知的二进制格式，让接收着可以在远端解压。
我所谓的 ＂已知的二进制格式＂是什麽意思呢？
好的，我们已经看过了 htons() 范例了，不是吗？它将数字从 host 格式改变［或是 ＂编码＂］为 Network Byte Order 格式；如果要反转［译码］这个数字，接收端会调用 ntohs()。
可是我不是才刚说过，没有这样的函数可供非整数型别使用吗？
是的，我说过。而且因为 C 语言并没有规范标准的方式来做，所以这有点麻烦［that a gratuitous pun there for you Python fans］。
要做的事情是将数据封装到已知的格式，并透过网路送出。例如：封装 float，这里的东西有很大的改善空间：[28]
#include <stdint.h>
uint32_t htonf(float f)
{
uint32_t p;
uint32_t sign;
if (f < 0) { sign = 1; f = -f; }
else { sign = 0; }
p = ((((uint32_t)f)&0x7fff)<<16) | (sign<<31); // whole part and sign
p |= (uint32_t)(((f - (int)f) * 65536.0f))&0xffff; // fraction
return p;
}
float ntohf(uint32_t p)
{
float f = ((p>>16)&0x7fff); // whole part
f += (p&0xffff) / 65536.0f; // fraction
if (((p>>31)&0x1) == 0x1) { f = -f; } // sign bit set
return f;
}
上列的代码是一个 native（原生的）实作，将 float 储存为 32-bit 的数字。High bit（高比特）［31］用来储存数字的正负号［＂1＂表示负数］，而接下来的七个比特［30-16］是用来储存 float 整个数字的部分。最後，剩下的比特［15-0］用来储存数字的小数（fractional portion）部分。
使用方式相当直觉：
#include <stdio.h>
int main(void)
{
float f = 3.1415926, f2;
uint32_t netf;
netf = htonf(f); // 转换为 "network" 形式
f2 = ntohf(netf); // 转回测试
printf("Original: %f\n", f); // 3.141593
printf(" Network: 0x%08X\n", netf); // 0x0003243F
printf("Unpacked: %f\n", f2); // 3.141586
return 0;
}
好处是：它很小丶很简单且快速，缺点是：它在空间的使用没有效率，而且对范围有严格的限制－试着在那边储存一个大於 32767 的数，它就会不高兴！
你也可以在上面的例子看到，最後一对的十进位空间并没有正确保存。
我们该怎麽改呢？
好的，用来储存浮点数（float point number）的标准方式是已知的 IEEE-754 [29]。多数的电脑会在内部使用这个格式做浮点运算，所以在这些例子里，严格说来，不需要做转换。但是如果你想要你的代码具可移植性，就要假设你不需要转换。［换句话说，如果你想要让程 序很快，你应该要在不需要做转换的平台上进行最佳化！这就是 htons() 与它的家族使用的方法。］
这边有段代码可以将 float 与 double 编码为 IEEE-754 格式 [30]。［主要的功能，它不会编码 NaN 或 Infinity，不过可以将它改成可以。］
#define pack754_32(f) (pack754((f), 32, 8))
#define pack754_64(f) (pack754((f), 64, 11))
#define unpack754_32(i) (unpack754((i), 32, 8))
#define unpack754_64(i) (unpack754((i), 64, 11))
uint64_t pack754(long double f, unsigned bits, unsigned expbits)
{
long double fnorm;
int shift;
long long sign, exp, significand;
unsigned significandbits = bits - expbits - 1; // -1 for sign bit
if (f == 0.0) return 0; // get this special case out of the way
// 检查正负号并开始正规化
if (f < 0) { sign = 1; fnorm = -f; }
else { sign = 0; fnorm = f; }
// 取得 f 的正规化型式并追踪指数
shift = 0;
while(fnorm >= 2.0) { fnorm /= 2.0; shift++; }
while(fnorm < 1.0) { fnorm *= 2.0; shift--; }
fnorm = fnorm - 1.0;
// 计算有效位数数据的二进制格式（非浮点数）
significand = fnorm * ((1LL<<significandbits) + 0.5f);
// get the biased exponent
exp = shift + ((1<<(expbits-1)) - 1); // shift + bias
// 返回最後的解答
return (sign<<(bits-1)) | (exp<<(bits-expbits-1)) | significand;
}
long double unpack754(uint64_t i, unsigned bits, unsigned expbits)
{
long double result;
long long shift;
unsigned bias;
unsigned significandbits = bits - expbits - 1; // -1 for sign bit
if (i == 0) return 0.0;
// pull the significand
result = (i&((1LL<<significandbits)-1)); // mask
result /= (1LL<<significandbits); // convert back to float
result += 1.0f; // add the one back on
// deal with the exponent
bias = (1<<(expbits-1)) - 1;
shift = ((i>>significandbits)&((1LL<<expbits)-1)) - bias;
while(shift > 0) { result *= 2.0; shift--; }
while(shift < 0) { result /= 2.0; shift++; }
// sign it
result *= (i>>(bits-1))&1? -1.0: 1.0;
return result;
}
我在那里的顶端放一些方便的 macro 用来封装与解除封装 32-bit［或许是 float］与 64-bit［或许是 double］的数字，但是 pack754() 函数可以直接调用，并告知编码几个比特的数据［expbits 的哪几个比特要保留给正规化数值的指数。］
这里是使用范例：
#include <stdio.h>
#include <stdint.h> // 定义 uintN_t 型别
#include <inttypes.h> // 定义 PRIx macros
int main(void)
{
float f = 3.1415926, f2;
double d = 3.14159265358979323, d2;
uint32_t fi;
uint64_t di;
fi = pack754_32(f);
f2 = unpack754_32(fi);
di = pack754_64(d);
d2 = unpack754_64(di);
printf("float before : %.7f\n", f);
printf("float encoded: 0x%08" PRIx32 "\n", fi);
printf("float after : %.7f\n\n", f2);
printf("double before : %.20lf\n", d);
printf("double encoded: 0x%016" PRIx64 "\n", di);
printf("double after : %.20lf\n", d2);
return 0;
}
上面的代码会产生下列的输出：
float before : 3.1415925
float encoded: 0x40490FDA
float after : 3.1415925
double before : 3.14159265358979311600
double encoded: 0x400921FB54442D18
double after : 3.14159265358979311600
你可能遭遇的另一个问题是你该如何封装 struct 呢？
对你来说没有问题的，编译器会自动将一个 struct 中的全部空间填入。［你不会病到听成 ＂不能这样做＂丶＂不能那样做＂？抱歉！引述一个朋友的话 ：＂当事情出错了，我都会责怪 Microsoft。＂这次固然可能不是 Microsoft 的错，不过我朋友的陈述完全符合事实。］
回到这边，透过网路送出 struct 的最好方式是将每个栏位独立封装，并接着在它们抵达另一端时，将它们解封装到 struct。
你正在想，这样要做很多事情。是的，的确是。一件你能做的事情是写一个有用的函数来帮你封装数据，这很好玩！真的！
在 Kernighan 与 Pike 着作的 ＂The Practice of Programming＂[31] 这本书，他们实作类似 printf() 的函数，名为 pack() 与 unpack()，可以完全做到这件事。我想要连结到这些函数，但是这些函数显然地无法从网路上取得。
［The Practice of Programming 是值得阅读的好书，Zeus saves a kitten every time I recommend it。］
此时，我正要舍弃指向我从未用过的 BSD 授权类型的参数语言 C API（BSD-licensed Typed Parameter Language C API）[32] 的指针，可是看起来整个很可敬。Python 与 Perl 程序设计师想要找出他们语言的 pack() 与 unpack() 函数，用来完成同样的事情。而 Java 有一个能用於同样用途的 big-ol' Serializable interface。
不过如果你想要用 C 写你自己的封装工具，K&P 的技巧是使用变动参数列（variable argument list），来让类似 printf() 的函数建立数据包。我自己所编造的版本 [33] 希望足以供你了解这样的东西是如何运作的。
［这段代码参考到上面的 pack754() 函数，packi*() 函数的运作方式类似 htons() 家族，除非它们是封装到一个 char 数组（array）而不是另一个整数。］
#include <ctype.h>
#include <stdarg.h>
#include <string.h>
#include <stdint.h>
#include <inttypes.h>
// 供浮点数型别的变动比特
// 随着架构而变动
typedef float float32_t;
typedef double float64_t;
/*
** packi16() -- store a 16-bit int into a char buffer (like htons())
*/
void packi16(unsigned char *buf, unsigned int i)
{
*buf++ = i>>8; *buf++ = i;
}
/*
** packi32() -- store a 32-bit int into a char buffer (like htonl())
*/
void packi32(unsigned char *buf, unsigned long i)
{
*buf++ = i>>24; *buf++ = i>>16;
*buf++ = i>>8; *buf++ = i;
}
/*
** unpacki16() -- unpack a 16-bit int from a char buffer (like ntohs())
*/
unsigned int unpacki16(unsigned char *buf)
{
return (buf[0]<<8) | buf[1];
}
/*
** unpacki32() -- unpack a 32-bit int from a char buffer (like ntohl())
*/
unsigned long unpacki32(unsigned char *buf)
{
return (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
}
/*
** pack() -- store data dictated by the format string in the buffer
**
** h - 16-bit l - 32-bit
** c - 8-bit char f - float, 32-bit
** s - string (16-bit length is automatically prepended)
*/
int32_t pack(unsigned char *buf, char *format, ...)
{
va_list ap;
int16_t h;
int32_t l;
int8_t c;
float32_t f;
char *s;
int32_t size = 0, len;
va_start(ap, format);
for(; *format != '\0'; format++) {
switch(*format) {
case 'h': // 16-bit
size += 2;
h = (int16_t)va_arg(ap, int); // promoted
packi16(buf, h);
buf += 2;
break;
case 'l': // 32-bit
size += 4;
l = va_arg(ap, int32_t);
packi32(buf, l);
buf += 4;
break;
case 'c': // 8-bit
size += 1;
c = (int8_t)va_arg(ap, int); // promoted
*buf++ = (c>>0)&0xff;
break;
case 'f': // float
size += 4;
f = (float32_t)va_arg(ap, double); // promoted
l = pack754_32(f); // convert to IEEE 754
packi32(buf, l);
buf += 4;
break;
case 's': // string
s = va_arg(ap, char*);
len = strlen(s);
size += len + 2;
packi16(buf, len);
buf += 2;
memcpy(buf, s, len);
buf += len;
break;
}
}
va_end(ap);
return size;
}
/*
** unpack() -- unpack data dictated by the format string into the buffer
*/
void unpack(unsigned char *buf, char *format, ...)
{
va_list ap;
int16_t *h;
int32_t *l;
int32_t pf;
int8_t *c;
float32_t *f;
char *s;
int32_t len, count, maxstrlen=0;
va_start(ap, format);
for(; *format != '\0'; format++) {
switch(*format) {
case 'h': // 16-bit
h = va_arg(ap, int16_t*);
*h = unpacki16(buf);
buf += 2;
break;
case 'l': // 32-bit
l = va_arg(ap, int32_t*);
*l = unpacki32(buf);
buf += 4;
break;
case 'c': // 8-bit
c = va_arg(ap, int8_t*);
*c = *buf++;
break;
case 'f': // float
f = va_arg(ap, float32_t*);
pf = unpacki32(buf);
buf += 4;
*f = unpack754_32(pf);
break;
case 's': // string
s = va_arg(ap, char*);
len = unpacki16(buf);
buf += 2;
if (maxstrlen > 0 && len > maxstrlen) count = maxstrlen - 1;
else count = len;
memcpy(s, buf, count);
s[count] = '\0';
buf += len;
break;
default:
if (isdigit(*format)) { // track max str len
maxstrlen = maxstrlen * 10 + (*format-'0');
}
}
if (!isdigit(*format)) maxstrlen = 0;
}
va_end(ap);
}
不管你是自己写的程序，或者用别人的代码，基於持续检查 bugs 的理由，能有通用的数据封装机制集是个好主意，而且不用每次都手动封装每个 bit（比特）。
在封装数据时，使用哪种格式会比较好呢？
好问题，很幸运地，RFC 4506 [35]，the External Data Representation Standard 已经定义了一堆各类型的二进位格式，如：浮点数型别丶整数型别丶数组丶原始数据等。如果你打算自己写程序来封装数据，我建议要与标准符合。只是不会强制你一定要这样做。数据包的政策不会刚好就在你门口。至少，我不认为它们会在。
不管怎样，在你送出数据以前，以某种或其它方法将数据编码是对的做事方法。
[27] http://en.wikipedia.org/wiki/Internet_Relay_Chat
[28] http://beej.us/guide/bgnet/examples/pack.c
[29] http://en.wikipedia.org/wiki/IEEE_754
[30] http://beej.us/guide/bgnet/examples/ieee754.c
[31] http://cm.bell-labs.com/cm/cs/tpop/
[32] http://tpl.sourceforge.net/
[33] http://beej.us/guide/bgnet/examples/pack2.c
Last modified 10mo ago