Boost序列化指针

Boost.Serialization 还能序列化指针和引用。 由于指针存储对象的地址，序列化对象的地址没有什么意义，而是在序列化指针和引用时，对象的引用被自动地序列化。

代码

#include  
#include  
#include  
#include  

std::stringstream ss; 

class person 
{ 
public: 
  person() 
  { 
  } 

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

  int age() const 
  { 
    return age_; 
  } 

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

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

  int age_; 
}; 

void save() 
{ 
  boost::archive::text_oarchive oa(ss); 
  person *p = new person(31); 
  oa << p; 
  std::cout << std::hex << p << std::endl; 
  delete p; 
} 

void load() 
{ 
  boost::archive::text_iarchive ia(ss); 
  person *p; 
  ia >> p; 
  std::cout << std::hex << p << std::endl; 
  std::cout << p->age() << std::endl; 
  delete p; 
} 

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

结果

0x1ff7bd0
0x1ff7830
1f

上面的应用程序创建了一个新的 person 类型的对象，使用 new 创建并赋值给指针 p 。 是指针 - 而不是 *p - 被序列化了。Boost.Serialization 自动地通过 p 的引用序列化对象本身而不是对象的地址。

如果归档被恢复， p 不必指向相同的地址。 而是创建新对象并将它的地址赋值给 p 。 Boost.Serialization 只保证对象和之前序列化的对象相同，而不是地址相同。

由于新式的 C++ 在动态分配内存有关的地方使用 智能指针 (smart pointers) ， Boost.Serialization 对此也提供了相应的支持。

#include  
#include  
#include  
#include  
#include  
#include  

std::stringstream ss; 

class person 
{ 
public: 
  person() 
  { 
  } 

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

  int age() const 
  { 
    return age_; 
  } 

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

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

  int age_; 
}; 

void save() 
{ 
  boost::archive::text_oarchive oa(ss); 
  boost::scoped_ptr<person> p(new person(31)); 
  oa << p; 
} 

void load() 
{ 
  boost::archive::text_iarchive ia(ss); 
  boost::scoped_ptr<person> p; 
  ia >> p; 
  std::cout << p->age() << std::endl; 
} 

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

例子中使用了智能指针 boost::scoped_ptr 来管理动态分配的 person 类型的对象。 为了序列化这样的指针，必须包含 boost/serialization/scoped_ptr.hpp 头文件。

在使用 boost::shared_ptr 类型的智能指针的时候需要序列化，那么必须包含 boost/serialization/shared_ptr.hpp 头文件。

下面的应用程序使用引用替代了指针。

#include  
#include  
#include  
#include  

std::stringstream ss; 

class person 
{ 
public: 
  person() 
  { 
  } 

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

  int age() const 
  { 
    return age_; 
  } 

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

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

  int age_; 
}; 

void save() 
{ 
  boost::archive::text_oarchive oa(ss); 
  person p(31); 
  person &pp = p; 
  std::cout<<&p<<std::endl;
  oa << pp; 
} 

void load() 
{ 
  boost::archive::text_iarchive ia(ss); 
  person p; 
  person &pp = p; 
  ia >> pp; 
  std::cout <<&p<<" "<<pp.age() << std::endl; 
} 

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

输出结果

0x7ffc362e9360
0x7ffc362e9360 31

指针数组

#include 
#include 
#include 
#include 
#include 
#include 

const int ARRAY_SIZE = 3;

class SomeType {
public:
    SomeType() : value(0) {}
    SomeType(int val) : value(val) {}

    int getValue() const { return value; }

    // 添加序列化函数
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version) {
        ar & value;
    }

private:
    int value;
};

class MyClass {
    friend class boost::serialization::access;

public:
    MyClass() = default;

    int data;
    SomeType* pointers[ARRAY_SIZE];

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

        for (int i = 0; i < ARRAY_SIZE; ++i) {
            ar & pointers[i];
        }
    }
};

int main() {
    MyClass obj;
    obj.data = 42;

    for (int i = 0; i < ARRAY_SIZE; ++i) {
        obj.pointers[i] = new SomeType(i * 10);
    }

    {
        std::ofstream file("my_class_data.txt");
        boost::archive::text_oarchive oa(file);
        oa << obj;
    }

    for (int i = 0; i < ARRAY_SIZE; ++i) {
        delete obj.pointers[i];
    }

    MyClass loadedObj;
    {
        std::ifstream file("my_class_data.txt");
        boost::archive::text_iarchive ia(file);
        ia >> loadedObj;
    }

    std::cout << "Loaded Object Data: " << loadedObj.data << std::endl;

    for (int i = 0; i < ARRAY_SIZE; ++i) {
    	std::cout << loadedObj.pointers[i]->getValue()<< std::endl;
        delete loadedObj.pointers[i];
    }

    return 0;
}