C++基本功之 对象序列化

稍微正式一点的应用都会用到对象的序列化/反序列化操作，常见的需求包括：

对象的持久存储。比如把一个对象存储到文件；在需要的时候，再把对象从文件中读出来；

对象的传递。比如要把一个对象通过管道，socket等任何手段传送到对端；

从数据构建对象。对象类型未知，但是我们可以从数据中构建一个对象出来。

 

我们现在来分析这些需求。看看C++如何有效地序列化/反序列化对象。下文中，凡提到序列化，都包含相应的反序列化。

 

一个对象的状态由其所有的内部成员状态决定。所以序列化对象其实可以等价于序列化其内部对象，递归地，其内部对象的序列化又可以归于构成这些内部对象的序列化。我们可以发现，到了最后，所有的对象构成都归于基本类型的序列化。

 

注意，这里的讨论并不适用于任何的资源管理类对象。

 

首先，我们需要的是最基本的支持，亦即对C++基本类型的序列化和反序列化；同时，由于标准库中的字符串类使用极为广泛，我们同样加入支持；最后，我们也加入对非格式的POD数据的支持，这样，据大多数的序列化需求应该可以得到满足。以下直接给出实现，其后是简单的说明，请仔细揣摩。

namespace persistent { const long true_pattern = 0xF00DF00D; const long false_pattern = 0xBAD0BAD0; class serializer { public: serializer (std::ostream& os) : _ostream(os) {} void put_char(char value) { return put_basic_t<char>(value); } void put_wchar(wchar_t value) { return put_basic_t<wchar_t>(value); } void put_bool(bool value) { return put_basic_t<bool>(value); } void put_short(short value) { return put_basic_t<short>(value); } void put_long(long value) { return put_basic_t<long>(value); } void put_llong(int64 value) { return put_basic_t<int64>(value); } void put_double(double value) { return put_basic_t<double>(value); } void put_string(const std::string& value) { return put_string_t<std::string>(value); } void put_wstring(const std::wstring& value) { return put_string_t<std::wstring>(value); } void put_raw(size_t length, const byte* buff) { put_long(static_cast<long>(length)); _ostream.write(reinterpret_cast<const char*>(buff), static_cast<std::streamsize>(length)); if (_ostream.bad()) throw std::exception("stream_write"); } void put_raw(const util::raw_buffer& buff) { _ostream.write(reinterpret_cast<const char*>(buff.operator const byte*()), static_cast<std::streamsize>(buff.size())); if (_ostream.bad()) throw std::exception("stream_write"); } protected: template<typename T> void put_basic_t(T value) { _ostream.write (reinterpret_cast<char*>(&value), sizeof(T)); if (_ostream.bad()) throw std::exception("stream_write"); } template<> void put_basic_t(bool value) { long pattern = value? true_pattern: false_pattern; put_long(pattern); if (_ostream.bad()) throw std::exception("stream_write"); } template<typename T> void put_string_t(const T& value) { long len = static_cast<long>(value.length() * sizeof(T::value_type)); put_long(len); _ostream.write(reinterpret_cast<const char*>(value.data()), len); if (_ostream.bad()) throw std::exception("stream_write"); } private: std::ostream& _ostream; serializer& operator =(const serializer&); }; class deserializer { public: deserializer (std::istream& is) : _istream(is) {} char get_char() { return get_basic_t<char>(); } wchar_t get_wchar() { return get_basic_t<wchar_t>(); } bool get_bool() { return get_basic_t<bool>(); } short get_short() { return get_basic_t<short>(); } long get_long() { return get_basic_t<long>(); } int64 get_llong() { return get_basic_t<int64>(); } double get_double() { return get_basic_t<double>(); } std::string get_string() { return get_string_t<std::string>(); } std::wstring get_wstring() { return get_string_t<std::wstring>(); } util::raw_buffer get_raw() { size_t length = static_cast<size_t>(get_long()); if (_istream.eof()) throw std::exception("unexpected_eof"); util::raw_buffer value(length); _istream.read(value.force_to<char*>(), static_cast<std::streamsize>(length)); if (_istream.bad()) throw std::exception("stream_read"); return value; } void get_raw(util::raw_buffer& buff) { if (_istream.eof()) throw std::exception("unexpected_eof"); _istream.read(buff.force_to<char*>(), static_cast<std::streamsize>(buff.size())); if (_istream.bad()) throw std::exception("stream_read"); } protected: template <typename T> T get_basic_t() { if (_istream.eof()) throw std::exception("unexpected_eof"); T value; _istream.read(reinterpret_cast<char *>(&value), sizeof(T)); if (_istream.bad()) throw std::exception("stream_read"); return value; } template<> bool get_basic_t() { long value = get_long(); if (_istream.bad()) throw std::exception("stream_read"); if (value == true_pattern) return true; else if (value == false_pattern) return false; else throw std::exception("data_corrupt"); } template<typename T> T get_string_t() { long len = get_long(); T value; value.resize(len / sizeof(T::value_type)); if (_istream.eof()) throw std::exception("unexpected_eof"); _istream.read(reinterpret_cast<char*>(&value[0]), len); if (_istream.bad()) throw std::exception("stream_read"); return value; } private: std::istream& _istream; deserializer& operator =(const deserializer&); }; } 

说明：

1. 使用独立的名字空间，避免名字冲突；

2. 对于bool型，理论上使用一个bit就可以表达其所有的信息。但是我们实际使用还是一个字节，因为这是内存操作的最小单位。为了有效地利用额外的信息，我们这里加入了对bool的校验，使用两个特殊的值；这两个值可以是任意值，只要不同即可。

3. 实现两个类，分别完成基本对象，字符串及其宽字符版本以及POD数据的序列化和反序列化；

4. 使用成员模板来消除基本对象序列化/反序列话过程中的代码重复；

5. 对于I/O操作失败，我们直接抛出异常。注意，这不是临时方案。而是经过仔细设计的序列化/反序列化过程的错误处理机制；

6. 构造这些对象需要输出或输入流对象，而不仅仅限于文件；

 

有了这个基础，我们就可以设计通用的序列化/反序列化接口了，非常简单：

namespace persistent { class serializable { public: virtual void serialize(serializer& out) const = 0; virtual void deserialize(deserializer& in) = 0; }; } 

 

那么，这个接口怎么使用呢？假设你有如下类，如果实现对其序列化/反序列化的支持呢？

struct mydata { char _c; wchar_t _w; bool _b; short _s; long _l; int64 _64; double _d; std::string _str; std::wstring _wstr; }; 

 

下面就是实现代码以及用来测试的代码：

struct mydata : public serializable { char _c; wchar_t _w; bool _b; short _s; long _l; int64 _64; double _d; std::string _str; std::wstring _wstr; public: virtual void serialize(serializer& out) const { out.put_char(_c); out.put_wchar(_w); out.put_bool(_b); out.put_short(_s); out.put_long(_l); out.put_llong(_64); out.put_double(_d); out.put_string(_str); out.put_wstring(_wstr); } virtual void deserialize(deserializer& in) { _c = in.get_char(); _w = in.get_wchar(); _b = in.get_bool(); _s = in.get_short(); _l = in.get_long(); _64 = in.get_llong(); _d = in.get_double(); _str = in.get_string(); _wstr = in.get_wstring(); } bool operator == (const mydata& r) { return _c == r._c && _w == r._w && _b == r._b && _s == r._s && _l == r._l && _64 == r._64 && _d == r._d && _str == r._str && _wstr == r._wstr; } }; void test_serializer() { mydata data; data._c = 'X'; data._w = L'q'; data._b = false; data._s = 12; data._l = 75543; data._64 = 0xabcdef0123; data._d = 12.47; data._str = "hello"; data._wstr = L"world"; std::stringstream ssm; serializer s(ssm); data.serialize(s); mydata data2; deserializer ds(ssm); data2.deserialize(ds); assert(data == data2); } 

 

注意到了吗？实现一个对象的序列化/反序列化操作需要：

1. 从接口serializable中继承

2. 实现相应的接口。对于序列化，按照顺序依次把成员写入流；对于反序列化，则要严格按照相反的顺序依次读入

3. 如果某个成员不是基本数据类型，有两种选择：a. 实现该成员所属类型的序列化/反序列化，然后直接调用之；b. 直接序列化该成员的子成员。这样做会严重破坏对象的完整性，所以非常不推荐使用。

 

实现了对象的序列话之后，使用起来就特别容易了。在我们的测试代码中，我们把对象序列化为一个字串，然后反序列化之到另一个对象。我们最后得到两个状态完全一致的对象。如果我们把该字串通过socket传到远方，实际上就是对象的远程传递了。所有流行的远程对象调用都是用类似的基础机制达成其目的。