求自定义类对象序列化原理和方案,该怎么解决

求自定义类对象序列化原理和方案
网络通信经常需要使用序列化，而C++又不像Java、C#本身就实现了序列化功能，那么C++如何对一个自定义类对象进行序列化和反序列化呢？请指教！另外，最好能够提供一些例程，谢谢！

如下面的类：

C/C++ code


class msg
{
public:
     ... ...

private:
     string id;
     string name;
     string data;
};

------解决方案--------------------
1.提供一个私有方法 bool CircularBuffer::_Put(const void* pData, int nSize);
功能：将一段数据拷贝到自己的存储区。

2.重写每种类型的序列化方法
//下面是针对内建类型
template <typename T>
inline CircularBuffer & CircularBuffer::operator<<( const T& data )
{
Put(&data, sizeof(data));
return *this;
}

// 针对各种STL容器，以及自己定义的类
inline CircularBuffer& CircularBuffer::operator<< ( const std::string & str)
{
*this << str.size();
Put(str.c_str(), str.size());
return *this;
}

//
3 自己定义的类
class msg
{
public:
friend CircularBuffer& operator<< (CircularBuffer& cb, const msg& message)
{
return cb << message.id << message.name << message.data;
}

private:
string id;
string name;
string data;
};

------解决方案--------------------
http://wenku.baidu.com/view/456122c30c22590102029d67.html
------解决方案--------------------
可以看看boost的序列化库。

C/C++ code

#include <fstream>
#include <iostream>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
class A
{
private:
    //为了能让串行化类库能够访问私有成员，所以要声明一个友元类
    friend class boost::serialization::access;
    //对象的数据
    int a;
    double b;
    //串行化的函数，这一个函数完成对象的保存与恢复
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & a; //就是这么简单，也可以使用 ar<<a 这样的语法
        ar & b;
    }
public:
    A(int aa, double bb) :
            a(aa),
            b(bb)
    {
    }
    A()
    {
    }
    void print()
    {
        std::cout << a << ' ' << b << std::endl;
    }
};
int main()
{
    std::ofstream fout("file.txt"); //把对象写到file.txt文件中
    boost::archive::text_oarchive oa(fout); //文本的输出归档类，使用一个ostream来构造
    A obj(1, 2.5);
    oa << obj; //保存obj对象
    fout.close(); //关闭文件

    std::ifstream fin("file.txt");
    boost::archive::text_iarchive ia(fin); //文本的输入归档类
    A newobj;
    ia >> newobj; //恢复到newobj对象
    newobj.print();
    fin.close();
    system("pause");
    return 0;
}

------解决方案--------------------
boost::serialization
protocol buffer
thrift
都有缺陷
protocol buffer
thrift
对自定义的类的成员对象不支持（我没用过）
boost::serialization
对自定义的类的成员的多态指针支持不好，不能自动识别。

C++下目前还没有java那样好的序列化，主要是C++没有反射

------解决方案--------------------
Boost使用很简单。
否则象一楼说的一样也可以。

关键技巧在于，给你的类里写一个接口，序列化和反序列化都使用这个接口，
所以你具体的序列化方案，或接口中序列化变量的顺序都不重要。

Class ClassA{
  int a;
  int b;
  ClassC c;
  virtual void serialize(Archive& ar)  //真正负责序列化或反序列化的是Archive的子类
  {
 ar.io(a);
 ar.io(b);
 ar.io(c)
  }
}

class Archive｛
  virtual void io(int );
  virtual void io(double );
  template<class T>     //递归自己定义的类
  void io(T t){
 t.io(*this);
  }
｝  
Boost使用很简单。
否则象一楼说的一样也可以。

关键技巧在于，给你的类里写一个接口，序列化和反序列化都使用这个接口

Class ClassA{
  int a;
  int b;
  ClassC c;

求自定义类对象序列化原理和方案,该怎么解决

相关推荐