利用Boost库进行序列化

 

第一部分：VS2010+Boost:

（一）下载安装Boost库
下载地址：http://www.boost.org/
安装到指定目录下，例如：
E:\boost_1_51

（二）在VS2010中使用Boost库
配置Boost库
配置include路径
Visual Studio -> 项目名称上单击右键 -> 属性 -> 配置属性 -> VC++ 目录 -> Include 目录 -> 点击编辑
填入内容：E:\boost_1_51

配置lib路径
Visual Studio -> 项目名称上单击右键 -> 属性 -> 配置属性 -> VC++ 目录 -> Library目录 -> 点击编辑
填入内容：E:\boost_1_51\lib

 

第二部分：序列化

详细的使用说明可以参见Boost官网上的tutorial：
http://www.boost.org/doc/libs/1_52_0/libs/serialization/doc/index.html

 

 为什么要序列化？
        我们希望能够将类对象的成员变量中的值保存下来，以便下次直接恢复使用。这可以通过序列化来实现，即将这些变量值保持下来，以后需要时直接将保持值恢复到类对象的成员变量中。简言之，通过序列化可以保持对象的状态。

序列化工具：
          通过Boost库，我们可以方便地实现对类对象的序列化。

 
 
 
下面通过三个例子来说明Boost库的三种使用方法（注：不止这三种）。
例1—Intrusion Version
现有一个Person类，声明和定义如下：

Person.h

class Person
{
public:
Person() ;
Person(int _age, std::string _name) ;
~Person() ;

void addScore(const float _score) ;

private:

int m_age ;
std::string m_name ;
std::vector<float> m_score ;

};

Person.cpp

Person::Person()
{
m_age = 0 ;
m_name = "name" ;

}

Person::~Person()
{
if (m_score.size() > 0)
{
m_score.clear() ;
}
}

Person::Person(int _age, std::string _name):m_age(_age), m_name(_name)
{

}

void Person::addScore(const float _score)
{
m_score.push_back(_score) ;
}

序列化后的Person类：
Person.h

class Person
{
public:
Person() ;
Person(int _age, std::string _name) ;
~Person() ;

void addScore(const float _score) ;

private:

friend class boost::serialization::access ;

template<class Archive>
void serialize(Archive & ar, const unsigned int version)
{
ar & m_age ;
ar & m_name ;
ar & m_score ;
}

private:

int m_age ;
std::string m_name ;
std::vector<float> m_score ;

};

测试程序：

Person onePerson(25, "fang") ;
onePerson.addScore(95.2f) ;

std::ofstream ofs("out.bin", std::ios_base::binary) ;
if (ofs.is_open())
{
boost::archive::binary_oarchive oa(ofs) ;
oa << onePerson ;
}

Person otherPerson ;
std::ifstream ifs("out.bin", std::ios_base::binary) ;
if (ifs.is_open())
{
boost::archive::binary_iarchive oa(ifs) ;
oa >> otherPerson ;
}

     

即在Person类中添加如上红色部分代码即可。在serialize()函数中，序列化类成员变量。这里根据自己的需要，可以选择序列化某几个变量，不一定要全部都序列化。

通过例子可以看到，Intrusion Version需要修改原先的类。

    
 
例2——Non Intrusion Version

现有一个Animal类，声明和定义如下：

Animal.h

class Animal
{
public:
Animal() ;
Animal(int _age, std::string _name) ;
~Animal() ;

void addScore(const float _score) ;

public:

int m_age ;
std::string m_name ;
std::vector<float> m_score ;

};

Animal.cpp 

Animal::Animal()
{
m_age = 0 ;
m_name = "name" ;

}

Animal::~Animal()
{
if (m_score.size() > 0)
{
m_score.clear() ;
}
}

Animal::Animal(int _age, std::string _name):m_age(_age), m_name(_name)
{

}

void Animal::addScore(const float _score)
{
m_score.push_back(_score) ;
}

序列化后的Animal类：

class Animal
{
public:
Animal() ;
Animal(int _age, std::string _name) ;
~Animal() ;

void addScore(const float _score) ;

public:

int m_age ;
std::string m_name ;
std::vector<float> m_score ;

};

namespace boost
{
namespace serialization
{
template<class Archive>
void serialize(Archive & ar, Animal & animal, const unsigned int version)
{
ar & animal.m_age ;
ar & animal.m_name ;
ar & animal.m_score ;
}

}
}

 

测试程序：

  Animal oneAnimal(25, "dog") ;
oneAnimal.addScore(95.2f) ;

std::ofstream ofs("outAnimal.bin", std::ios_base::binary) ;
if (ofs.is_open())
{
boost::archive::binary_oarchive oa(ofs) ;
oa << oneAnimal ;
}

Animal otherAnimal ;
std::ifstream ifs("outAnimal.bin", std::ios_base::binary) ;
if (ifs.is_open())
{
boost::archive::binary_iarchive oa(ifs) ;
oa >> otherAnimal;
}

     

该例与例1的不同在于：不需要对原来的类进行修改。但这种用法需要类成员变量时public类型的。

 
例3———Non Intrusion Version

现有一个Plant类，声明和定义如下：
Plant.h

class Plant
{
public:
Plant() ;
Plant(int _age, std::string _name) ;
~Plant() ;

void addScore(const float _score) ;

public:

void setScore(const std::vector<float> _scoreVct) ;
std::vector<float> getScore() const ;

int m_age ;
std::string m_name ;

private:
std::vector<float> m_score ;

};

Plant.cpp

Plant::Plant()
{
m_age = 0 ;
m_name = "name" ;

}

Plant::~Plant()
{
if (m_score.size() > 0)
{
m_score.clear() ;
}
}

Plant::Plant(int _age, std::string _name):m_age(_age), m_name(_name)
{

}

void Plant::addScore(const float _score)
{
m_score.push_back(_score) ;
}

void Plant::setScore(const std::vector<float> _scoreVct)
{
m_score = _scoreVct ;
}

std::vector<float> Plant::getScore() const
{
return m_score ;
}

序列化后的Plant类：
Plant.h

class Plant
{
public:
Plant() ;
Plant(int _age, std::string _name) ;
~Plant() ;

void addScore(const float _score) ;

public:

void setScore(const std::vector<float> _scoreVct) ;
std::vector<float> getScore() const ;

int m_age ;
std::string m_name ;

private:
std::vector<float> m_score ;

};

// 通过该宏，将序列化分为：load 和 save
// 这样的好处在于：load 和 save 两个函数可以编写不同代码
// 而前面两个例子中的serialize函数即充当load，又充当save
BOOST_SERIALIZATION_SPLIT_FREE(Plant)

namespace boost
{
namespace serialization
{
template<class Archive>
void save(Archive & ar, const Plant & plant, const unsigned int version)
{
ar & plant.m_age ;
ar & plant.m_name ;

// 通过公共函数来获取私有成员变量
std::vector<float> scores(plant.getScore());
ar & scores ;
}

template<class Archive>
void load(Archive & ar, Plant & plant, const unsigned int version)
{
ar & plant.m_age ;
ar & plant.m_name ;

// 通过公共函数来设置私有成员变量
std::vector<float> scores ;
ar & scores ;
plant.setScore(scores) ;

}

}
}

测试程序：

                                       

Plant onePlant(25, "tree") ;
onePlant.addScore(95.2f) ;

std::ofstream ofs("outPlant.bin", std::ios_base::binary) ;
if (ofs.is_open())
{
boost::archive::binary_oarchive oa(ofs) ;
oa << onePlant ;
}

Plant otherPlant ;
std::ifstream ifs("outPlant.bin", std::ios_base::binary) ;
if (ifs.is_open())
{
boost::archive::binary_iarchive oa(ifs) ;
oa >> otherPlant;
}

 

该例与例2的区别在于：

    1）该类的序列化操作被分解为了两个动作：load和save。load和save两个函数内部的操作可以不同，我们可以为其分别编写不同的代码；前面两个例子中的serialize函数即充当了load又充当了save，在序列化时充当的是save的角色，在反序列化时充当的是load的角色。

    2）对于不是public类型的成员变量，我们可以通过public类型的成员函数来对其进行读写操作，从而也能够对其进行序列化。

[/code]

-------------------------------------------------------

< 转载请注明：http://blog.csdn.net/icvpr >