稍微正式一點的應用都會用到物件的序列化/反序列化操作，常見的需求包括：

物件的持久儲存。比如把一個物件儲存到檔案；在需要的時候，再把物件從檔案中讀出來；

物件的傳遞。比如要把一個物件通過管道，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傳到遠方，實際上就是物件的遠端傳遞了。所有流行的遠端物件呼叫都是用類似的基礎機制達成其目的。