boost.serialization中基类指针容器存子类对象的序列化

// serialize.cpp : 定义控制台应用程序的入口点。
//通过基类指针容器来实现序列化
//NB啊

//需要注意的是BOOST_CLASS_EXPORT_GUID好想是不支持boost编译成动态库的

//建议大家还是采用register_type的做法来注册子类，这样很保险
//2014-7-4 made by davidsu33

#include "stdafx.h"
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/vector.hpp>

#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>

#include <vector>
#include <sstream>
#include <iostream>
#include <list>

using namespace std;

class Base
{
public:
	virtual ~Base(){}
	void setX(int x) {m_x = x;}
	int getX() const {return m_x;}
private:
	friend class boost::serialization::access;
	template<class Archive>
	void serialize( Archive & ar, const unsigned int file_version )
	{
		ar & m_x;
	}

private:
	int m_x;
};

class Derived : public Base
{
public:
	void setY(int y) {m_y = y;}
	int getY() const {return m_y;}
private:
	friend class boost::serialization::access;
	template <class Archive>
	void serialize( Archive & ar, const unsigned int file_version )
	{
		ar & boost::serialization::base_object<Base>(*this) & m_y;

	}

private:
	int m_y;
};

class Derived2 : public Base
{
public:
	void setY(int k) {m_k = k;}
	int getY() const {return m_k;}
private:
	friend class boost::serialization::access;
	template <class Archive>
	void serialize( Archive & ar, const unsigned int file_version )
	{
		ar & boost::serialization::base_object<Base>(*this) & m_k;

	}

private:
	int m_k;
};

class DDerived : public Derived
{
public:
	void setZ(int z){m_z = z;}
	int getZ() const {return m_z;}

private:
	friend class boost::serialization::access;
	template<class Archive>
	void serialize( Archive & ar, const unsigned int file_version )
	{
		ar & boost::serialization::base_object<Derived>(*this) & m_z;
	}

private:
	int m_z;
};

//实现多态序列化，需要将子类在boost.serilization中进行注册
//BOOST_CLASS_EXPORT_KEY2(classname, "ID")
//BOOST_CLASS_EXPORT_IMPLEMENT(classname)
//也可以动态的通过调用register_type来实现动态注册
//下面是动态实现的操作

//#define BOOST_CLASS_EXPORT_GUID(T, K)                                  \
//<span style="white-space:pre">	</span>BOOST_CLASS_EXPORT_KEY2(T, K)                                          \
//<span style="white-space:pre">	</span>BOOST_CLASS_EXPORT_IMPLEMENT(T)                                        \

//BOOST_CLASS_EXPORT_GUID等价于CLASS的声明和定义

//需要增加头文件

//#include <boost/serialization/export.hpp>

#define REGISTERTYPE(x,type) \
	x##.template register_type<type>();

template<class T>
void registerTypes(T & ar)
{
	REGISTERTYPE(ar, Derived)
	REGISTERTYPE(ar, Derived2)
	REGISTERTYPE(ar, DDerived)
}

void serialize_poly()
{
	std::vector<Base*> pVector;

	Base * p = NULL;

	p = new Base;
	p->setX(1);
	pVector.push_back(p);

	p = new Derived;
	p->setX(2);
	pVector.push_back(p);

	p = new Derived2;
	p->setX(3);
	pVector.push_back(p);

	p = new DDerived;
	p->setX(4);
	pVector.push_back(p);

	//序列化到字符数据流中
	ostringstream ostrstream;
	boost::archive::binary_oarchive oar(ostrstream);

	//***********************************************
	//必须要注册，否则子类的类型不认
	//***********************************************

	//动态注册
	registerTypes(oar);//自动类型推导

	//写入数据流中
	oar << pVector;
	oar << p;

	//清除缓存
	ostrstream.flush();

	//从数据流中读取出来
	istringstream istrstream(ostrstream.str());
	boost::archive::binary_iarchive iar(istrstream);

	//动态注册
	registerTypes(iar);

	//读取数据
	std::vector<Base*> pReadVector;
	Base* pReadPolyObj = NULL;

	iar >> pReadVector;
	iar >> pReadPolyObj;
}

int _tmain(int argc, _TCHAR* argv[])
{
	serialize_poly();
	getchar();
	return 0;
}