畅游C++ Boost Serialization 序列化

最新推荐文章于 2024-03-09 20:48:34 发布
最新推荐文章于 2024-03-09 20:48:34 发布
阅读量7.7k 收藏 25
点赞数 6
分类专栏： C++ 文章标签： boost 序列化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq2399431200/article/details/45621921
版权

畅游C++ Boost Serialization 序列化

目录


1.工作环境

2.使用方法

3.工程下载

4.总结

5.参考文献

6.更新

7.C++ Boost::serialization简介


内容

1.工作环境

        VS2010 C++，Windows 7，Boost _1_55_0


2.使用方法

       1.到Boost官网下载对应操作系统平台下的Boost库，此库需要进行编译以生成“静态”和“共享”库。具体编译方法请上网搜索；

       2.包含解压后的头文件路径到工程中：VS2010|选择工程|属性|配置属性|VC++目录|

                              包含目录|添加“D:\C++\Boost\boost_1_55_0”    —— boost库头文件路径

                              库目录|添加“D:\C++\Boost\boost_1_55_0\stage\lib”  —— boost库.lib或.dll文件路径


2.1第一个简单的例子 —— Hello World ，将字符串内容归档到文本文件中

#include <iostream>
#include <fstream>
#include <string>
#include <cstdio>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

// 清单1.将字符串保存到文本归档文件中
void save()
{
	std::ofstream file("archive.txt");
	boost::archive::text_oarchive oa(file);
	std::string s = "Hello world\n";
	oa << s;  // oa & s; 清单3.使用&运算符执行“转储-恢复”操作
}

// 清单2.将字符串的内容加载到文本文件中
void load()
{
	std::ifstream file("archive.txt");
	boost::archive::text_iarchive ia(file);
	std::string s;
	ia >> s;  // ia & s; 清单3.使用&运算符执行“转储-恢复”操作
	std::cout << s << std::endl;
}

int main()
{
	save();
	load();
	getchar();
}

2.2从xml文档文件执行“转储-恢复”操作

// 清单4

#include <iostream>
#include <fstream>
#include <string>
#include <cstdio>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>

void save()
{
	std::ofstream file("archive.xml");
	boost::archive::xml_oarchive oa(file);
	std::string s = "Hello world! 你好，世界！\n";
	//如果您想使用 XML 归档文件，而不是文本归档文件,需要将数据打包到一个名为 BOOST_SERIALIZATION_NVP 的宏中
	oa & BOOST_SERIALIZATION_NVP(s);  
}

void load()
{
	std::ifstream file("archive.xml");
	boost::archive::xml_iarchive ia(file);
	std::string s;
	ia & BOOST_SERIALIZATION_NVP(s);
	std::cout << s << std::endl;
}

int main()
{
	save();
	load();
	getchar();
}
xml归档文件中的内容： 

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<s>Hello world! 你好，世界！
</s>
</boost_serialization>


2.3对整数数组执行“转储-恢复”操作

// 清单6

#include <fstream>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstdio>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>

void save()
{
	std::ofstream file("archive.xml");
	boost::archive::xml_oarchive oa(file);
	int arrary1[ ] = { 34, 78, 22, 1, 910 };
	oa & BOOST_SERIALIZATION_NVP(arrary1);
}

/*  是否可以仅通过指定指针 int* restored 完成此操作并为您恢复数组？
答案是否定的。必须每次都指定大小。如果认真回答此问题的话，答案是对基本
类型的指针进行序列化非常复杂。*/
void load()
{
	std::ifstream file("archive.xml");
	boost::archive::xml_iarchive ia(file);
	int restored[5];  //必须指定数组的大小
	ia & BOOST_SERIALIZATION_NVP(restored);
	std::ostream_iterator<int> oi(std::cout, " ");
	std::copy(restored, restored+5, oi);
}

int main()
{
	save();
	load();
	getchar();
}
xml归档文件中的内容： 

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<arrary1>
	<count>5</count>
	<item>34</item>
	<item>78</item>
	<item>22</item>
	<item>1</item>
	<item>910</item>
</arrary1>
</boost_serialization>


2.4串行化STL集合

// 清单8

#include <iostream>
#include <fstream>
#include <algorithm>
#include <iterator>
#include <cstdio>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/vector.hpp>

void save( )
{
	std::ofstream file("archive.xml");
	boost::archive::xml_oarchive oa(file);
	float array[ ] = {34.2, 78.1, 22.221, 1.0, -910.88};
	std::list<float> L1(array, array+5);
	std::vector<float> V1(array, array+5);
	oa & BOOST_SERIALIZATION_NVP(L1);
	oa & BOOST_SERIALIZATION_NVP(V1);
}

void load()
{
	std::ifstream file("archive.xml");
	boost::archive::xml_iarchive ia(file);
	std::list<float> L2;
	ia >> BOOST_SERIALIZATION_NVP(L2);  //不需要指定范围/大小

	std::vector<float> V2;
	ia >> BOOST_SERIALIZATION_NVP(V2);  //不需要指定范围/大小

	std::ostream_iterator<float> oi(std::cout, " ");
	std::copy(L2.begin(), L2.end(), oi );
	std::copy(V2.begin(), V2.end(), oi );
}

int main()
{
	save();
	load();
	getchar();
}

xml归档文件中内容： 

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<L1>
	<count>5</count>
	<item_version>0</item_version>
	<item>34.200001</item>
	<item>78.099998</item>
	<item>22.221001</item>
	<item>1</item>
	<item>-910.88</item>
</L1>
<V1>
	<count>5</count>
	<item_version>0</item_version>
	<item>34.200001</item>
	<item>78.099998</item>
	<item>22.221001</item>
	<item>1</item>
	<item>-910.88</item>
</V1>
</boost_serialization>

2.5序列化自己的类型——serialize方法的侵入版本 

// 清单10 所谓“侵入”即serialize方法写到类中

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <iostream>
#include <fstream>
#include <cstdio>

namespace 
{
	using std::cout;
	using std::cin;
	using std::endl;
}

typedef struct date
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;

	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "month:" << d.m_month << "year:" << d.m_year;
		return out;
	}
	template<typename Archive>
	void serialize(Archive& archive, const unsigned int version)
	{
		archive & BOOST_SERIALIZATION_NVP(m_day);
		archive & BOOST_SERIALIZATION_NVP(m_month);
		archive & BOOST_SERIALIZATION_NVP(m_year);
	}
}date;

void save( )
{
	std::ofstream file("archive.xml");
	boost::archive::xml_oarchive oa(file);
	date d(15, 8, 1947);
	oa & BOOST_SERIALIZATION_NVP(d);
}

void load( )
{
	std::ifstream file("archive.xml");
	boost::archive::xml_iarchive ia(file);
	date dr;
	ia >> BOOST_SERIALIZATION_NVP(dr);
	std::cout << dr;
}

int main(void)
{
	save();
	load();
	getchar();
}

xml归档文件的内容：

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<d class_id="0" tracking_level="0" version="0">
	<m_day>15</m_day>
	<m_month>8</m_month>
	<m_year>1947</m_year>
</d>
</boost_serialization>

2.6序列化自己的类型——serialize方法的非侵入版本 

// 清单11 所谓“非侵入”即serialize方法不必写在类中、不属于类

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <iostream>
#include <fstream>
#include <cstdio>

namespace 
{
	using std::cout;
	using std::cin;
	using std::endl;
}

typedef struct date
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;

	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "month:" << d.m_month << "year:" << d.m_year;
		return out;
	}
}date;

// 序列化相关的类和函数都属于boost::serialization命名空间里，所以自定义的serialize函数也可被其中的其它类和函数调用
namespace boost
{
	namespace serialization
	{
		template<typename Archive>
		void serialize(Archive& archive, date& d, const unsigned int version)
		{
			archive & BOOST_SERIALIZATION_NVP(d.m_day);
			archive & BOOST_SERIALIZATION_NVP(d.m_month);
			archive & BOOST_SERIALIZATION_NVP(d.m_year);
		}
	}
}


void save( )
{
	std::ofstream file("archive.xml");
	boost::archive::xml_oarchive oa(file);
	date d(15, 8, 1947);
	oa & BOOST_SERIALIZATION_NVP(d);
}

void load( )
{
	std::ifstream file("archive.xml");
	boost::archive::xml_iarchive ia(file);
	date dr;
	ia >> BOOST_SERIALIZATION_NVP(dr);
	std::cout << dr;
}

int main(void)
{
	save();
	load();
	getchar();
}

2.7通过基类指针转储派生类——使用xml文件归档

// 清单13

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <string>

namespace 
{
	using std::cout;
	using std::cin;
	using std::endl;
	using std::string;
}

class CBase
{
	friend class boost::serialization::access;
	template<typename Archive>
	void serialize(Archive& ar, const unsigned int version) { ar & BOOST_SERIALIZATION_NVP(baseName); }
	string baseName;
public:
	CBase( ) { baseName = "class CBase"; }
	virtual ~CBase( ) { }  //必须加一个virtual函数，否则“dynamic_cast<date*> (dr)”报error C2683: “dynamic_cast”:“CBase”不是多态类型 错误
	                      //这是C++多态属性决定的
};


class date : public CBase
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;
public:
	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "\nmonth:" << d.m_month << "\nyear:" << d.m_year;
		return out;
	}
	virtual ~date() { }
private:
	friend class boost::serialization::access;
	template<typename Archive>
	void serialize(Archive& archive, const unsigned int version)
	{
		//archive & boost::serialization::base_object<CBase> (*this);  //用文本文档归档用此方法，当用于xml归档时会发生error C2664: “boost::mpl::assertion_failed”: 不能将参数 1 从“boost::mpl::failed ************boost::serialization::is_wrapper<T>::* ***********”转换为“boost::mpl::assert<false>::type”
		
                archive & BOOST_SERIALIZATION_BASE_OBJECT_NVP(CBase);   //用xml归档时，需要将父类对象包装，即用此宏，否则发生如上错误提示
		
                archive & BOOST_SERIALIZATION_NVP(m_day);
		archive & BOOST_SERIALIZATION_NVP(m_month);
		archive & BOOST_SERIALIZATION_NVP(m_year);
	}
};

void save( )
{
	std::ofstream file("archive.xml");
	boost::archive::xml_oarchive oa(file);
	oa.register_type<date>();
	CBase *b = new date(16, 8, 1947);
	oa & BOOST_SERIALIZATION_NVP(b);
	delete b;
}

void load( )
{
	std::ifstream file("archive.xml");
	boost::archive::xml_iarchive ia(file);
	ia.register_type<date>();
	CBase *dr;
	ia >> BOOST_SERIALIZATION_NVP(dr);
	date *dr2 = dynamic_cast<date*> (dr);
	std::cout << *dr2;
	delete dr2;
}

int main(void)
{
	save();
	getchar();
	load();
	getchar();
}

xml归档文件的内容：

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<b class_id="0" tracking_level="1" version="0" object_id="_0">
	<CBase class_id="1" tracking_level="1" version="0" object_id="_1">
		<baseName>class CBase</baseName>
	</CBase>
	<m_day>16</m_day>
	<m_month>8</m_month>
	<m_year>1947</m_year>
</b>
</boost_serialization>

2.8通过基类指针转储派生类——使用文本文件归档 

// 注意和“3.7”的区别

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <string>

namespace 
{
	using std::cout;
	using std::cin;
	using std::endl;
	using std::string;
}

class CBase
{
	friend class boost::serialization::access;
	template<typename Archive>
	void serialize(Archive& ar, const unsigned int version) { ar & baseName; }
	string baseName;
public:
	CBase( ) { baseName = "class CBase"; }
	virtual ~CBase( ) { }  //必须加一个virtual函数，否则“dynamic_cast<date*> (dr)”报error C2683: “dynamic_cast”:“CBase”不是多态类型 错误
	//这是C++多态属性决定的
};


class date : public CBase
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;
public:
	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "\nmonth:" << d.m_month << "\nyear:" << d.m_year;
		return out;
	}
	virtual ~date() { }
private:
	friend class boost::serialization::access;
	template<typename Archive>
	void serialize(Archive& archive, const unsigned int version)
	{
		archive & boost::serialization::base_object<CBase> (*this);  //用文本文档归档用此方法，当用于xml归档时会发生error C2664: “boost::mpl::assertion_failed”: 不能将参数 1 从“boost::mpl::failed ************boost::serialization::is_wrapper<T>::* ***********”转换为“boost::mpl::assert<false>::type”
		//archive & BOOST_SERIALIZATION_BASE_OBJECT_NVP(CBase);   //用xml归档时，需要将父类对象包装，即用此宏，否则发生如上错误提示
		archive & m_day;
		archive & m_month;
		archive & m_year;
	}
};

void save( )
{
	std::ofstream file("archive.txt");
	boost::archive::text_oarchive oa(file);
	oa.register_type<date>();
	CBase *b = new date(16, 8, 1947);
	oa & b;
	delete b;
}

void load( )
{
	std::ifstream file("archive.txt");
	boost::archive::text_iarchive ia(file);
	ia.register_type<date>();
	CBase *dr;
	ia >> dr;
	date *dr2 = dynamic_cast<date*> (dr);
	std::cout << *dr2;
	delete dr2;
}

int main(void)
{
	save();
	getchar();
	load();
	getchar();
}
文本文件归档内容： 

22 serialization::archive 10 0 1 0
0 1 0
1 11 class CBase 16 8 1947

2.9使用指针执行“转储-恢复”操作 

// 清单15

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <iostream>
#include <fstream>
#include <cstdio>

namespace 
{
	using std::cout;
	using std::cin;
	using std::endl;
}

typedef struct date
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;

	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "month:" << d.m_month << "year:" << d.m_year;
		return out;
	}
	template<typename Archive>
	void serialize(Archive& archive, const unsigned int version)
	{
		archive & BOOST_SERIALIZATION_NVP(m_day);
		archive & BOOST_SERIALIZATION_NVP(m_month);
		archive & BOOST_SERIALIZATION_NVP(m_year);
	}
}date;

void save( )
{
	std::ofstream file("archive.xml");
	boost::archive::xml_oarchive oa(file);
	date *d = new date(15, 8, 1947);
	cout << d << endl;
	oa & BOOST_SERIALIZATION_NVP(d);
}

void load( )
{
	std::ifstream file("archive.xml");
	boost::archive::xml_iarchive ia(file);
	date *dr;
	ia >> BOOST_SERIALIZATION_NVP(dr);
	std::cout << dr << endl;
	cout << *dr;
}

int main(void)
{
    save();
    load();
    getchar();
} 

运行结果：

0047A108
0047A6B8
day:15month:8year:1947

xml归档文件中的内容：

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<d class_id="0" tracking_level="1" version="0" object_id="_0">
	<m_day>15</m_day>
	<m_month>8</m_month>
	<m_year>1947</m_year>
</d>
</boost_serialization>

2.10使用指针执行“转储-恢复”操作——将两个指针转储到同一个对象

// 清单17

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <iostream>
#include <fstream>
#include <cstdio>

namespace 
{
	using std::cout;
	using std::cin;
	using std::endl;
}

typedef struct date
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;

	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "month:" << d.m_month << "year:" << d.m_year;
		return out;
	}
	template<typename Archive>
	void serialize(Archive& archive, const unsigned int version)
	{
		archive & BOOST_SERIALIZATION_NVP(m_day);
		archive & BOOST_SERIALIZATION_NVP(m_month);
		archive & BOOST_SERIALIZATION_NVP(m_year);
	}
}date;

void save()
{
    std::ofstream file("archive.xml");
    boost::archive::xml_oarchive oa(file);
    date *d = new date(15,8,1947);
    cout << d << endl;
    oa & BOOST_SERIALIZATION_NVP(d);
    date *d2 = d;
    oa & BOOST_SERIALIZATION_NVP(d2);
}

void load()
{
    std::ifstream file("archive.xml");
    boost::archive::xml_iarchive ia(file);
    date *dr;
    ia >> BOOST_SERIALIZATION_NVP(dr);
    cout << dr << endl;
    cout << *dr << endl;
    date *dr2;
    ia >> BOOST_SERIALIZATION_NVP(dr2);
    cout << dr2 << endl;
    cout << *dr2;
}

int main(void)
{
    save();
    load();
    getchar();
}

运行结果：

0010A108
0010A6B8
day:15month:8year:1947
0010A6B8
day:15month:8year:1947

xml归档文件中的内容：

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<d class_id="0" tracking_level="1" version="0" object_id="_0">
	<m_day>15</m_day>
	<m_month>8</m_month>
	<m_year>1947</m_year>
</d>
<d2 class_id_reference="0" object_id_reference="_0"></d2>
</boost_serialization>

2.11包含作为d的引用d2的归档文件

// 清单19  和参考网页(IBM)中的那部分不一致

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <iostream>
#include <fstream>
#include <cstdio>

namespace 
{
	using std::cout;
	using std::cin;
	using std::endl;
}

typedef struct date
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;

	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "month:" << d.m_month << "year:" << d.m_year;
		return out;
	}
	template<typename Archive>
	void serialize(Archive& archive, const unsigned int version)
	{
		archive & BOOST_SERIALIZATION_NVP(m_day);
		archive & BOOST_SERIALIZATION_NVP(m_month);
		archive & BOOST_SERIALIZATION_NVP(m_year);
	}
}date;

void save()
{
    std::ofstream file("archive.xml");
    boost::archive::xml_oarchive oa(file);
    date *d = new date(15,8,1947);
    cout << d << endl;
    oa & BOOST_SERIALIZATION_NVP(d);
    date* &d2 = d;     //d2 reference d
    oa & BOOST_SERIALIZATION_NVP(d2);  
}

void load()
{
    std::ifstream file("archive.xml");
    boost::archive::xml_iarchive ia(file);
    date *dr;
    ia >> BOOST_SERIALIZATION_NVP(dr);
    cout << dr << endl;
    cout << *dr << endl;
    date *dr2;
    ia >> BOOST_SERIALIZATION_NVP(dr2);
    cout << dr2 << endl;
    cout << *dr2;
}

int main(void)
{
    save();
    load();
    getchar();
}
xml归档文件的内容： 

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<d class_id="0" tracking_level="1" version="0" object_id="_0">
	<m_day>15</m_day>
	<m_month>8</m_month>
	<m_year>1947</m_year>
</d>
<d2 class_id_reference="0" object_id_reference="_0"></d2>
</boost_serialization>

2.12将serialize拆分成save和load

        有时候，您不想使用同样的 serialize 方法来转储和恢复对象。在这种情况下，您可以将 serialize 方法拆分成两个方法，即save 和load，它们具有类似的签名。这两个方法都是之前定义的serialize 方法的一部分。此外，需要添加BOOST_SERIALIZATION_SPLIT_MEMBER 宏作为类定义的一部分。（引用参考文献[1]）

// 清单21

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <iostream>
#include <fstream>
#include <cstdio>

namespace 
{
	using std::cout;
	using std::cin;
	using std::endl;
}

typedef struct date
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;

	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "month:" << d.m_month << "year:" << d.m_year;
		return out;
	}
// 	template<typename Archive>
// 	void serialize(Archive& archive, const unsigned int version)
// 	{
// 		archive & BOOST_SERIALIZATION_NVP(m_day);
// 		archive & BOOST_SERIALIZATION_NVP(m_month);
// 		archive & BOOST_SERIALIZATION_NVP(m_year);
// 	}
        //将serialize函数分割成save和load函数，两个者实现的效果是等价的
	template<class Archive>
	void save(Archive& archive, const unsigned int version) const //注意 save 方法签名后的 const。如果没有 const 限定符，该代码将无法编译
	{
		archive << BOOST_SERIALIZATION_NVP(m_day);
		archive << BOOST_SERIALIZATION_NVP(m_month);
		archive << BOOST_SERIALIZATION_NVP(m_year);
	} 

	template<class Archive>
	void load(Archive& archive, const unsigned int version)
	{
		archive >> BOOST_SERIALIZATION_NVP(m_day);
		archive >> BOOST_SERIALIZATION_NVP(m_month);
		archive >> BOOST_SERIALIZATION_NVP(m_year);
	} 
	BOOST_SERIALIZATION_SPLIT_MEMBER( ) // must be part of class
}date;

void save( )
{
	std::ofstream file("archive.xml");
	boost::archive::xml_oarchive oa(file);
	date d(15, 8, 1991);
	oa & BOOST_SERIALIZATION_NVP(d);
}

void load( )
{
	std::ifstream file("archive.xml");
	boost::archive::xml_iarchive ia(file);
	date dr;
	ia >> BOOST_SERIALIZATION_NVP(dr);
	std::cout << dr;
}

int main(void)
{
	save();
	load();
	getchar();
}

2.13了解Boost::serialize的版本控制

    serialize、save 和 load 的方法签名都使用无符号整数版本作为最后一个参数。这些数字有什么用？随着时间变化，类的内部变量名称可能发生变化，添加新的字段或移除已有字段，等等。这是软件开发过程中的自然进程，除了归档文件仍然保存着关于数据类型原有状态的信息。为了规避这个问题，需要使用版本号。(引用参考文献[1])

        在date类的基础上增加一个unsigned int  ver变量用于保存当前类Mydate的版本号。

// 清单22

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <iostream>
#include <fstream>
#include <cstdio>

namespace 
{
	using std::cout;
	using std::cin;
	using std::endl;
}

typedef struct date
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;

	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "month:" << d.m_month << "year:" << d.m_year << endl;
		return out;
	}
	template<typename Archive>
	void serialize(Archive& archive, const unsigned int version)
	{
		archive & BOOST_SERIALIZATION_NVP(m_day);
		archive & BOOST_SERIALIZATION_NVP(m_month);
		archive & BOOST_SERIALIZATION_NVP(m_year);
	}
}date;
BOOST_CLASS_VERSION(date,0);

// Mydate
typedef struct Mydate
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;
	unsigned int ver;  //版本

	Mydate(int d, int m, int y, int version):m_day(d), m_month(m) ,m_year(y), ver(version) {  }
	Mydate( ):m_day(1),m_month(1),m_year(2000),ver(1) { }
	friend std::ostream& operator << (std::ostream& out, Mydate& d)
	{
		out << "day:" << d.m_day << "month:" << d.m_month << "year:" << d.m_year << " -- Version:" << d.ver << endl;
		return out;
	}
	template<typename Archive>
	void serialize(Archive& archive, const unsigned int version)
	{
		archive & BOOST_SERIALIZATION_NVP(m_day);
		archive & BOOST_SERIALIZATION_NVP(m_month);
		archive & BOOST_SERIALIZATION_NVP(m_year);
		if(version == 1)
		{
			archive & BOOST_SERIALIZATION_NVP(ver);
		}
	}
}Mydate;
BOOST_CLASS_VERSION(Mydate,1);

void save( )
{
	std::ofstream file("version.xml");
	boost::archive::xml_oarchive oa(file);
	date d(15, 8, 1947);
	oa & BOOST_SERIALIZATION_NVP(d);
	Mydate myd(1, 1, 1991, 1);
	oa & BOOST_SERIALIZATION_NVP(myd);
}

void load( )
{
	std::ifstream file("version.xml");
	boost::archive::xml_iarchive ia(file);
	date dr;
	ia >> BOOST_SERIALIZATION_NVP(dr);
	Mydate myd;
	ia >> BOOST_SERIALIZATION_NVP(myd);
	std::cout << dr;
	std::cout << myd;
}

int main(void)
{
	save();
	load();
	getchar();
}

运行结果：

day:15month:8year:1947
day:1month:1year:1991 -- Version:1

xml归档文件中内容

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<d class_id="0" tracking_level="0" version="0">
	<m_day>15</m_day>
	<m_month>8</m_month>
	<m_year>1947</m_year>
</d>
<myd class_id="1" tracking_level="0" version="1">
	<m_day>1</m_day>
	<m_month>1</m_month>
	<m_year>1991</m_year>
	<ver>1</ver>
</myd>
</boost_serialization>

2.14 使用共享指针boost::shared_ptr执行“转储-恢复”操作

// 清单23 

#include <iostream>
#include <fstream>
#include <string>
#include <cstdio>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/shared_ptr.hpp>  //缺此头文件 —— error C2039: “serialize”: 不是“boost::shared_ptr<T>”的成员	d:\c++\boost\boost_1_55_0\boost\serialization\access.hpp


typedef struct date
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;

	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "month:" << d.m_month << "year:" << d.m_year;
		return out;
	}
	template<typename Archive>
	void serialize(Archive& archive, const unsigned int version)
	{
		archive & BOOST_SERIALIZATION_NVP(m_day);
		archive & BOOST_SERIALIZATION_NVP(m_month);
		archive & BOOST_SERIALIZATION_NVP(m_year);
	}
}date;

void save()
{
	std::ofstream file("shared_ptr.xml");
	boost::archive::xml_oarchive oa(file);
	boost::shared_ptr<date> d (new date(15, 8, 1947));
	oa & BOOST_SERIALIZATION_NVP(d);
	// other code bellow
}

void load()
{
	std::fstream file("shared_ptr.xml");
	boost::archive::xml_iarchive ia(file);
	boost::shared_ptr<date> dr;
	ia & BOOST_SERIALIZATION_NVP(dr);
	std::cout << *dr;
}

int main( )
{
	save();
	load();
	getchar();
}
xml文档中的内容： 

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<d class_id="0" tracking_level="0" version="1">
	<px class_id="1" tracking_level="1" version="0" object_id="_0">
		<m_day>15</m_day>
		<m_month>8</m_month>
		<m_year>1947</m_year>
	</px>
</d>
</boost_serialization>

2.15 指向栈对象的指针需要在实际对象之后转储

// 清单24 

#include <iostream>
#include <fstream>
#include <string>
#include <cstdio>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/shared_ptr.hpp>  //缺此头文件 —— error C2039: “serialize”: 不是“boost::shared_ptr<T>”的成员	d:\c++\boost\boost_1_55_0\boost\serialization\access.hpp


typedef struct date
{
	unsigned int m_day;
	unsigned int m_month;
	unsigned int m_year;

	date(int d, int m, int y):m_day(d), m_month(m) ,m_year(y) {  }
	date( ):m_day(1),m_month(1),m_year(2000) { }
	friend std::ostream& operator << (std::ostream& out, date& d)
	{
		out << "day:" << d.m_day << "month:" << d.m_month << "year:" << d.m_year;
		return out;
	}
	template<typename Archive>
	void serialize(Archive& archive, const unsigned int version)
	{
		archive & BOOST_SERIALIZATION_NVP(m_day);
		archive & BOOST_SERIALIZATION_NVP(m_month);
		archive & BOOST_SERIALIZATION_NVP(m_year);
	}
}date;

void save()
{
	std::ofstream file("stackobject.xml");
	boost::archive::xml_oarchive oa(file);
	date d(1,1,1991);
	date *d2 = &d;
	oa & BOOST_SERIALIZATION_NVP(d);  
	oa & BOOST_SERIALIZATION_NVP(d2);  //指向栈对象的指针需要在实际对象之后转储
}

void load()
{
	std::fstream file("stackobject.xml");
	boost::archive::xml_iarchive ia(file);
	date dr;
	ia & BOOST_SERIALIZATION_NVP(dr);
	std::cout << dr << std::endl;
	date *dr2;
	ia & BOOST_SERIALIZATION_NVP(dr2);
	std::cout << *dr2 << std::endl;
}

int main( )
{
	save();
	load();
	getchar();
}

xml文档中的内容： 

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="10">
<d class_id="0" tracking_level="1" version="0" object_id="_0">
<m_day>1</m_day>
<m_month>1</m_month>
<m_year>1991</m_year>
</d>
<d2 class_id_reference="0" object_id_reference="_0"></d2>
</boost_serialization>
           如果有多个指针指向同一个对象，Serialization 会使用 class_id_reference 将指针与原对象关联起来（每个对象都有一个唯一的类 ID）。原对象的每个后续指针都会将 object_id_reference 改成 _1、_2，以此类推。


3.工程下载

        整个工程的下载地址，点此处。


4.总结



5.参考文献

[1]. 《Boost Serialization 库》 http://www.ibm.com/developerworks/cn/aix/library/au-boostserialization/


6.更新

2015-05-10  第一次更新   全文开始，增加2.1~2.7 部分内容

2015-05-11  第二次更新    增加2.8~2.13部分内容

2015-05-14  第三次更新    增加2.14~2.15部分内容

2015-05-19  第四次更新    提供工程下载


7.C++ Boost::serialization简介

以下内容引用Boost库的“libs/serialization/doc/index.html”页面：    

         Here, we use the term "serialization" to meanthe reversible deconstruction of an arbitrary set of C++ data structuresto a sequence of bytes. Such a system can be used to reconstitutean equivalent structure in another program context. Depending onthe context, this might used implement object persistence, remoteparameter passing or other facility. In this system we use the term"archive" to refer to a specific rendering of thisstream of bytes. This could be a file of binary data, text data, XML, or some other created by the user of this library.

Our goals for such a system are:

  1. Code portability - depend only on ANSI C++ facilities.
  2. Code economy - exploit features of C++ such as RTTI, templates, and multiple inheritance, etc. where appropriate to make code shorter and simpler to use.
  3. Independent versioning for each class definition. That is, when a class definition changed, older files can still be imported to the new version of the class.
  4. Deep pointer save and restore. That is, save and restore of pointers saves and restores the data pointed to.
  5. Proper restoration of pointers to shared data.
  6. Serialization of STL containers and other commonly used templates.
  7. Data Portability - Streams of bytes created on one platform should be readable on any other.
  8. Orthogonal specification of class serialization and archive format. That is, any file format should be able to store serialization of any arbitrary set of C++ data structures without having to alter the serialization of any class.
  9. Non-intrusive. Permit serialization to be applied to unaltered classes. That is, don't require that classes to be serialized be derived from a specific base class or implement specified member functions. This is necessary to easily permit serialization to be applied to classes from class libraries that we cannot or don't want to have to alter.
  10. The archive interface must be simple enough to easily permit creation of a new type of archive.
  11. The archive interface must be rich enough to permit the creation of anarchive that presents serialized data as XML in a useful manner.

Other implementations

Before getting started I searched around for current implementations. I found several.
  • MFC This is the one that I am very familiar with. I have used it for several years and have found it very useful. However it fails requirements 1, 2, 3, 6, 7, and 9. In spite of all the requirements not fulfilled, this is the most useful implementation I've found. It turns out that class versioning - partially implemented in MFC - really is indispensable for my applications. Inevitably, version 1.x of a shipping program needs to store more information in files than was originally provided for. MFC is the only one of these implementations that supports this - though only for the most derived class. Still it's better than nothing and does the job. MFC doesn't implement serialization of STL collections. Though it does so for MFC collections.
  • CommonC++ libraries [1] As far as I can tell, this closely follows the MFC implementation but does address a few of the issues. It is portable and creates portable archives but skips versioning. It does support proper and complete restoration of pointers and STL collections. It does address compression though not in the way that I would prefer. The package would also benefit from having better documentation. So it fails to address 2, 3, 7, 8, and 9.
  • Eternity [2] This is a bare bones package. It seems well coded but it really needs documentation and examples. It's not obvious how to use it without time consuming study of the source code. Recent versions do support files in XML format. This Fails 3, 6, 7?, 8, and 9.
  • Holub's implementation [3] This is the article that first got me thinking about my own requirements for a serialization implementation. Interesting and worth the read if you can overlook the arrogant tone of the prose. This implementation fails 2, 3, 4, 5, and 6.
  • s11n [13] This library has similar goals to this one. Some aspects of the implemenation are also similar. As of this writing, it would seem that:
    • Portability(1) is guarenteed only for recent versions of GCC.
    • Versioning(3) of class definitions is not explicitly supported by the library.
    • it doesn't seem to automatically account for shared pointers(5). I concluded this from the documentation as well as the statement that serialization of graph like structures is not supported.
    Its has lots of differences - and lots in common with this implementation.





shmiloveyou
关注
  • 6
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Boost - 序列化 (Serialization)
zj510的专栏
10-24 4万+
程序开发中，序列化是经常需要用到的。像一些相对高级语言，比如JAVA, C#都已经很好的支持了序列化，那么C++呢？当然一个比较好的选择就是用Boost，这个号称C++准标准库的东西。 什么时候需要序列化呢？举个例子，我们定义了一个class，比如： class CCar { public: void SetName(std::string& strName){m_strName = str
C++使用Boost序列化对象
HWL_0099的博客
03-09 1187
前言 在做运动员管理系统的时候，我用到C++中的对象遇到一个问题，就是保存对象的时候，想要将对象保存保存在文件中，本来是直接这样子： int count = 0;//对象个数，即学生人数 fstream infile("e:\\student.txt",ios::in | ios::binary);//以读方式打开文件 if (!infile) {...
C++使用boost.serialization序列化与反序列化
a4364634611的博客
11-07 1315
侵入式序列化，非侵入式序列化 虽然看着有些长，但是请各位要注意，这是两个例子，分别介绍基本的普通类序列化与子类序列化，并反序列化 反序列化的代码其实都一样(只是把对象A改成了B)修改了构造函数传参。 特别关注 template void serialize(Archive& ar, const unsigned int version) 我们在后面都会用到 序列化STL容器
boost serialization 序列化/反序列化 详细用法
Max_Cong的博客
06-13 6187
##原文http://zh.highscore.de/cpp/boost/serialization.html 第 11 章 序列化 目录 11.1 概述11.2 归档11.3 指针和引用11.4 对象类层次结构的序列化11.5 优化用封装函数11.6 练习 该书采用 Creative Commons License 授权 11.1. 概述 Boos
4.4 C++ Boost 数据集序列化库
热门推荐
CSDN
08-21 1万+
Boost库提供了一组通用的数据序列化和反序列化库，包括archive、text_oarchive、text_iarchive、xml_oarchive、xml_iarchive等。可用于许多数据类型的持久化和传输。使用这些库，我们可以轻松地将各种数据类型序列化到文件或流中，并从文件或流中反序列化数据。
C++Boost的序列化
LuckyStar的博客
03-09 1111
date;侵入式版本{}{}return out;} date;date dr;序列化版本控制123public:CPerson();;~CPerson();private://要想序列化用户定义的类型 必须定义seriallze函数//serialzation不应该被显示调用 因为它仅在序列化或者反序列化的时候调用。
C++ Boost Serialization 序列化 boost::unordered_map
bug的博客
11-01 1202
$ cat serialization_unordered_map.h  /*******************************************************************************   # Author : Neo Fung   # Email : neosfung@gmail.com   # Last modified: 2011-11-18...
C++使用boost::serialization进行序列化
超爱吃小蛋糕的66的博客
06-09 584
发现一个比较好玩的东西，boost::serialization序列化操作，简单来说感觉像ofstream和ifstream的升级版，Boost.Serialization 库能够将c++项目中的对象转换为一序列的比特（bytes），用来保存和加载还原对象。
【C/C++ 序列化 】深入探索 Boost 序列化：从理论到实践的全面指南
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
12-14 1437
在现代软件开发中，数据的持久化和跨平台通信是两个核心问题。其中，数据序列化（Data Serialization）扮演着至关重要的角色。Boost 序列化库（Boost Serialization Library）为解决这些问题提供了强大而灵活的工具。
Java序列化(Serialization) 机制
09-02
Java序列化机制是Java平台提供的一种标准方法，用于将对象的状态转换为字节流，以便存储在磁盘上，或者在网络中进行传输。这使得Java对象可以在不同的Java虚拟机（JVM）之间交换，这对于分布式应用程序，如远程方法...
深入浅析Java Object Serialization与 Hadoop 序列化
08-30
深入浅析Java Object Serialization与 Hadoop 序列化 序列化是指将结构化对象转化为字节流以便在网络上传输或者写到磁盘永久存储的过程。Java 中的序列化是通过实现 Serializable 接口来实现的，而 Hadoop 序列化则...
boost-serialization-examples
05-15
Boost序列化示例 简而言之，序列化就是将任何数据结构转换为一种格式，该格式允许将数据写入支持文件（文件，套接字等）。 Boost提供了一个序列化库，该库带有针对POD和stl类型的开箱即用的序列化，但是它易于使用...
cereal:C++实现的开源序列化库
01-20
闲来无事发现了一个基于C++实现的序列化工具，相比于其他（比如Boost serialization或Google protobuf，恰巧都用过，以后再介绍），使用简单，感觉不错，下面做个摸索。 　cereal介绍 　cereal是一个开源的（BSD ...
Boost::Serialization存储C++对象
05-19
此压缩包包含12个项目，每个项目都着重讲解Boost::Serialization一个方面的使用技巧，有详细的代码介绍具体使用方法。
2024年欧洲化学电镀市场主要企业市场占有率及排名.docx
06-25
2024年欧洲化学电镀市场主要企业市场占有率及排名.docx
计算机本科生毕业论文1111
最新发布
06-25
老人服务系统
探索Elasticsearch的节点角色：集群的构建基石
06-25
Elasticsearch是一个基于Lucene的搜索引擎，它提供了一个分布式、多租户能力的全文搜索引擎，具有HTTP web接口和无模式的JSON文档。Elasticsearch是用Java编写的，但也可以作为服务在多种操作系统上运行，包括Windows、Linux和macOS。 ### Elasticsearch的主要特点包括： 1. **分布式性质**：Elasticsearch天生设计为分布式，可以很容易地扩展到数百台服务器，处理PB级别的数据。 2. **实时搜索**：Elasticsearch提供了快速的搜索能力，可以实时索引和搜索数据。 3. **高可用性**：通过自动分片和复制，Elasticsearch确保了数据的高可用性和容错性。 4. **多租户**：Elasticsearch支持多租户，允许多个用户或应用共享同一集群资源。 5. **丰富的查询语言**：Elasticsearch提供了强大的查询语言，支持结构化、非结构化数据的复杂搜索需求。 6. **横向扩展**：Elasticsearch可以通过简单地增加节点来扩展集群。 等
JAVA语言考试系统的设计与实现(论文+源代码+文献综述+外文翻译+开题报告).zip
06-25
JAVA语言考试系统的设计与实现(论文+源代码+文献综述+外文翻译+开题报告)
c++实现序列化和反序列化
07-28
引用\[1\]:要想使用网络框架的API来传输结构化的数据，必须得先实现结构化的数据与字节流之间的双向转换。这种将结构化数据转换成字节流的过程，称为序列化，反过来转换，就是反序列化。简单来说，序列化就是将对象实例的状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它依据流重构对象。\[2\]在C++中，可以使用一些库或框架来实现序列化和反序列化。比如，可以使用Boost库中的Serialization模块来实现对象的序列化和反序列化。Boost.Serialization提供了一种简单的方式来将C++对象序列化为字节流，并将字节流反序列化为原始对象。此外，C++标准库中也提供了一些序列化和反序列化的功能，比如使用iostream库中的<<和>>运算符重载来实现对象的序列化和反序列化。另外，还可以使用Google的Protocol Buffers库来实现C++对象的序列化和反序列化。这个库提供了一种语言无关、平台无关、可扩展的序列化机制，可以将结构化数据序列化为二进制格式，以便在不同的系统之间进行数据交换。总之，C++中有多种方法可以实现对象的序列化和反序列化，具体选择哪种方法取决于具体的需求和使用场景。 #### 引用[.reference_title] - *1* *2* [C++ 序列化和反序列化](https://blog.csdn.net/JMW1407/article/details/107173775)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [c++序列化以及反序列化实现](https://blog.csdn.net/qq_33521184/article/details/125228533)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值