使用boost序列化自定义类型

#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <boost/serialization/string.hpp> 
#include <boost/serialization/export.hpp> //声明了识别父类指针所指向的真正的类型的宏
#include <iostream> 
#include <fstream> 
#include <sstream> 
  
std::stringstream ss;

class person
{
public:
	person(){}
	person(int age,string n)
		: age_(age),name(n){}
	virtual ~person() {}
private:
	int age_;
	string name;

	//序列化
	//若类的成员为public，则不用声明为友元函数
	friend class boost::serialization::access;
	template <typename Archive>
	friend void serialize(Archive &ar, person &p, const unsigned int version);
};
template <typename Archive>
void serialize(Archive &ar, person &p, const unsigned int version)
{
	ar & p.age_;//&代表<<或>>
	ar & p.name;
}


//普通变量序列化
void save()
{
	boost::archive::text_oarchive oa(ss);
	person p(31,"bob");
	oa << p;
}
void load()
{
	boost::archive::text_iarchive ia(ss);
	person p;
	ia >> p;
}

//指针序列化
void saveptr()
{
	boost::archive::text_oarchive oa(ss);
	person *p = new person(31, "bob");
	oa << p;
	delete p;
}

void loadptr()
{
	boost::archive::text_iarchive ia(ss);
	person *p;
	ia >> p;
	delete p;
}



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

	student(int age, string n,int sc) 
		: person(age,  n),score(sc){}
	~student() {}
private:
	double score;

	//序列化
	//若类的成员为public，则不用声明为友元函数
	friend class boost::serialization::access;
	template <typename Archive>
	friend void serialize(Archive &ar, student &s, const unsigned int version);
};
template <typename Archive>
void serialize(Archive &ar, student &s, const unsigned int version)
{
	ar & boost::serialization::base_object<person>(s);//使用父类的序列化
	ar & s.score;//
}

//子类普通变量序列化
void saveSon()
{
	boost::archive::text_oarchive oa(ss);
	 student s(31, "bb",99.9);
	oa << s;
}

void loadSon()
{
	boost::archive::text_iarchive ia(ss);
	student s;
	ia >> s;
}

//指向子类对象的基类指针序列化
//BOOST_CLASS_EXPORT(student);//识别真正的类型，必须使用该宏，所有类都会注册
void saveSonptr()
{
	boost::archive::text_oarchive oa(ss);
	oa.register_type<student>();//只注册需要序列化的类
	person * p  = new student(31, "bb", 99.9);
	oa << p;
	delete p;
}

void loadSonptr()
{
	boost::archive::text_iarchive ia(ss);
	ia.register_type<student>();
	person * p;
	ia >> p;
	delete p;
}

int main()
{
	saveSonptr();
	loadSonptr();
}

 
 

#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <boost/serialization/string.hpp> 
#include <boost/serialization/export.hpp> //声明了识别父类指针所指向的真正的类型的宏
#include <iostream> 
#include <fstream> 
#include <sstream> 
  
std::stringstream ss;

class person
{
public:
    person(){}
    person(int age,string n)
        : age_(age),name(n){}
    virtual ~person() {}
private:
    int age_;
    string name;

    //序列化
    //若类的成员为public，则不用声明为友元函数
    friend class boost::serialization::access;
    template <typename Archive>
    friend void serialize(Archive &ar, person &p, const unsigned int version);
};
template <typename Archive>
void serialize(Archive &ar, person &p, const unsigned int version)
{
    ar & p.age_;//&代表<<或>>
    ar & p.name;
}
//普通变量
void save()
{
    boost::archive::text_oarchive oa(ss);
    person p(31,"bob");
    oa << p;
}
void load()
{
    boost::archive::text_iarchive ia(ss);
    person p;
    ia >> p;
}

//指针序列化
void saveptr()
{
    boost::archive::text_oarchive oa(ss);
    person *p = new person(31, "bob");
    oa << p;
    delete p;
}

void loadptr()
{
    boost::archive::text_iarchive ia(ss);
    person *p;
    ia >> p;
    delete p;
}

 

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

    student(int age, string n,int sc) 
        : person(age,  n),score(sc){}
    ~student() {}
private:
    double score;

    //序列化
    //若类的成员为public，则不用声明为友元函数
    friend class boost::serialization::access;
    template <typename Archive>
    friend void serialize(Archive &ar, student &s, const unsigned int version);
};
template <typename Archive>
void serialize(Archive &ar, student &s, const unsigned int version)
{
    ar & boost::serialization::base_object<person>(s);//使用父类的序列化
    ar & s.score;//
}

void saveSon()
{
    boost::archive::text_oarchive oa(ss);
     student s(31, "bb",99.9);
    oa << s;
}

void loadSon()
{
    boost::archive::text_iarchive ia(ss);
    student s;
    ia >> s;
}

//基类指针指向子类对象
BOOST_CLASS_EXPORT(student);//要是别真正的类型，必须使用该宏
void saveSonptr()
{
    boost::archive::text_oarchive oa(ss);
    oa.register_type<student>();
    person * p  = new student(31, "bb", 99.9);
    oa << p;
    delete p;
}

void loadSonptr()
{
    boost::archive::text_iarchive ia(ss);
    ia.register_type<student>();
    person * p;
    ia >> p;
    delete p;
}

int main()
{
    saveSonptr();
    loadSonptr();
}
 
 boost序列化几个重要的技术
 1.boost::archive::text_oarchive(序列化oa)和boost::archive::text_iarchive（反序列化ia）
 2.friend class boost::serialization::access;
 template <typename Archive>
 void serialize(Archive &ar, person &p, const unsigned int version);//定义类的成员序列化

 3.识别基类指针指向的类型的两种技术

1）BOOST_CLASS_EXPORT；子类对象需要通过基类的指针序列化所要使用的宏，缺点是可能有些注册的类最后是不需要序列化的
2） register_type<SonType>();只注册需要序列化的类，解决了BOOST_CLASS_EXPORT的缺点，序列化oa和反序列化ia都需要调用

4.ARCHIVE & boost::serialization::base_object<BaseType>(SonObject);//在子类序列化时，直接使用父类已经序列化好的成员，只需序列化子类特有成员

5.以下两个函数用于优化序列化  。
boost::serialization::make_array();   是用来序列化数组的,使用形式:oa >> boost::serialization::make_array(addr,size); 
boost::serialization::make_binary_object(); 用来序列化没有底层结构的二进制数据