boost vs2015 序列化 动态对象

问题 ： 需要将 list<person *> 序列化并保存到xml中，再将xml读取并得到 list<person *>，其中person是基类； 有其他的类作为其子类：developer和developer2等。

1. class person
   {
   public:
   	person()
   	{
   	}
   
   	person(int age)
   		: age_(age)
   	{
   	}
   
   	virtual int age() const
   	{
   		return age_;
   	}
   	virtual int kk() = 0;
   	pal pal1;
   	int age_;
   private:
   	friend class boost::serialization::access;
   
   	template <typename Archive>
   	void serialize(Archive &ar, const unsigned int version)
   	{
   		ar & age_;
   		ar & pal1;
   	}
   
   
   };
   
   class developer
   	: public person
   {
   public:
   	developer()
   	{
   	}
   
   	developer(int age, const std::string &language)
   		: person(age), language_(language)
   	{
   	}
   
   	std::string language() const
   	{
   		return language_;
   	}
   	virtual int kk() {
   		return 11;
   	}
   	virtual int age() {
   
   		return 199;
   
   	}
   private:
   	friend class boost::serialization::access;
   
   	template <typename Archive>
   	void serialize(Archive &ar, const unsigned int version)
   	{
   		ar & boost::serialization::base_object<person>(*this);
   		ar & language_;
   	}
   
   	std::string language_;
   };
   

第一步 下载boost；

这个网上有许多，但是不编译的就需要在官网上下载预编译的版本，这个根据自己电脑的安装环境选择，

（编译的版本很多，但是容易出问题，我使用命令行几次都报错，网上也没人解答类似的问题，还很花时间， 这个https://blog.csdn.net/misterfm/article/details/79048594 看起来还不错）

官网地址： https://www.boost.org/ （官网）和https://www.boost.org/users/download/（下载地址）

参考：https://blog.csdn.net/feierban/article/details/80283727

  我下载的boost_1_68_0-msvc-14.0-32.exe ，14.0是指vs2015，32= 32位系统；

下好以后，运行得到：

其实lib32-msvc-14.0这个目录就是编译好的目录（包含各种lib和dll）；

打开vs2015，在项目的属性 vc++

接着链接器的附加库目录：编译好的目录

接着在代码中添加#include 就会发现有boost目录

这就是vs2015添加比较快的方法，还有更快的，就是打开 属性-》管理nuget程序包，

查找boost就行了，但是我的程序还是提示有错，最后又加载了附加目录库（D:\local\boost_1_68_0\lib32-msvc-14.0）就好了。

第二步 boost 序列化；

参考 https://blog.csdn.net/wojiushiwoba/article/details/59527911；这个是大致了解概念；

具体实现参考：http://zh.highscore.de/cpp/boost/serialization.html和https://blog.csdn.net/zj510/article/details/8105408

1 boost serialization；头文件

#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <boost/serialization/string.hpp> 

主要的转化
#include <boost/serialization/export.hpp> 

宏
#include<boost\serialization\list.hpp>

对象中 list类的转换
#include <iostream> 
#include <sstream> 

输入输出流
#include <string> 

2 boost serialization  侵入式（非侵入式没写）

在类中加入

friend class boost::serialization::access;

    template <typename Archive>
    void serialize(Archive &ar, const unsigned int version)
    {

//类中需要序列化的；可以支持指针
        ar & sss;
    }

所有需要序列化的都要在serialize中，而且基类对象或成员对象中也需要实现serialize；

从上面可以看出，boost是使用text_oarchive和text_iarchive 类，来完成一个对象的序列化的。使用这两个类的步骤是：

 在源程序中包含boost/archive/text_oarchive.hpp 和 boost/archive/text_iarchive.hpp 这两个文件。

 为需要序列化的类添加一个template<class Archive> void serialize(Archive & ar, const unsigned int version)的模版成员函数。 如果需要对象中包含私有成员的话，需要把boost::serialization::access类声明为友元。

 在主函数中，创建一个输出文件流对象， 使用这个对象构造一个text_oarchive对象，然后就可以使用<<操作符来输出对象了。

 最后，同样的，使用text_iarchive来恢复对象。(xml 类似)

重点：在基类中需要是一个虚函数（可以让boost知道是基类），这里我将person的一个函数kk变为纯虚函数，在develop中实现kk。子类需要定义BOOST_CLASS_EXPORT(developer)。

第三步测试

mian.cpp

#include "stdafx.h"
#include <iostream>
#include <string>
#include <string>
#include <sstream>
using namespace std;
void TestPointerArchive();
std::stringstream ss;
std::stringstream ss1;
void save1()
{
	boost::archive::text_oarchive oa(ss);
	boost::archive::text_oarchive oa2(ss1);
	person *p = new developer(31, "C++");
	person *p2 = new developer2(32, "C+2+");
	oa << p<<p2;
	oa2 << p2;
	delete p2;
	delete p;
}

void load1()
{
	boost::archive::text_iarchive ia(ss);
	boost::archive::text_iarchive ia2(ss1);
	person *p;
	person *p2;
	person *p3;

	ia >> p;
	ia >> p3;
	ia2 >> p2;
	std::cout << p->kk() << std::endl;
	std::cout << p3->kk() << std::endl;
	std::cout << p2->kk() << std::endl;
	delete p;
	delete p2;
}



int main()
{


	list<person *> listp;
	list<person *> listp2;
	boost::archive::text_oarchive oa(ss);
	person *p = new developer(31, "C++");
	person *p2 = new developer2(32, "C+2+");

	test *tt = new test();
	tt->sss = 99;

	pal *pal2 = new pal();
	pal2->bb = 111;
	pal2->kk = 112;
	pal2->test1 = tt->cloner();


	pal *pal3 = pal2->cloner();
	pal3->kk = 113;
	p->pal1 = *pal2;
	p2->pal1 = *pal3;


	listp.push_back(p);
	listp.push_back(p2);
	oa << listp;

	boost::archive::text_iarchive ia(ss);

	ia >> listp2;

	for each (person*p in listp2)
	{
		std::cout << p->kk()<<"   "<<p->pal1.test1->sss << std::endl;
	}
}

boost1.cpp

#pragma once
#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <boost/serialization/string.hpp> 
#include <boost/serialization/export.hpp> 
#include<boost\serialization\list.hpp>
#include <iostream> 
#include <sstream> 
#include <string> 


class test
{
public:
	int sss;

	test * cloner() {
		test *t = new test();

		*t = *this;

		return t;


	}
private:
	friend class boost::serialization::access;

	template <typename Archive>
	void serialize(Archive &ar, const unsigned int version)
	{
		ar & sss;
	}
};



class pal {
public:

	int kk;
	int bb;
	test *test1;
	pal * cloner() {

		pal *a = new pal();
		*a = *this;
		return a;
	}
private:
	friend class boost::serialization::access;

	template <typename Archive>
	void serialize(Archive &ar, const unsigned int version)
	{
		ar & kk;
		ar & bb;
		ar &test1;
	}


};

class person
{
public:
	person()
	{
	}

	person(int age)
		: age_(age)
	{
	}

	virtual int age() const
	{
		return age_;
	}
	virtual int kk() = 0;


	pal pal1;
	int age_;
private:
	friend class boost::serialization::access;

	template <typename Archive>
	void serialize(Archive &ar, const unsigned int version)
	{
		ar & age_;
		ar & pal1;
	}


};

class developer
	: public person
{
public:
	developer()
	{
	}

	developer(int age, const std::string &language)
		: person(age), language_(language)
	{
	}

	std::string language() const
	{
		return language_;
	}
	virtual int kk() {
		return 11;
	}
	virtual int age() {

		return 199;

	}
private:
	friend class boost::serialization::access;

	template <typename Archive>
	void serialize(Archive &ar, const unsigned int version)
	{
		ar & boost::serialization::base_object<person>(*this);
		ar & language_;
	}

	std::string language_;
};

class developer2
	: public person
{
public:
	developer2()
	{
	}

	developer2(int age, const std::string &language)
		: person(age), language_(language)
	{
	}

	std::string language() const
	{
		return language_;
	}
	virtual int kk() {
		return 12;
	}
	virtual int age() {

		return 1992;

	}
private:
	friend class boost::serialization::access;

	template <typename Archive>
	void serialize(Archive &ar, const unsigned int version)
	{
		ar & boost::serialization::base_object<person>(*this);
		ar & language_;
	}

	std::string language_;
};

BOOST_CLASS_EXPORT(developer)

BOOST_CLASS_EXPORT(developer2)

测试项目  github：https://github.com/gzj1997/boost-3