A类

A.h

#ifndef __A_H__
#define __A_H__

#include <utility>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>

class A {
public:
    A(int a, int b);
    virtual ~A() = default;

private:
    std::pair<int, int> _pair;

private:
    // 打算序列化的类必须有默认构造函数
    A() = default;

    // 序列化所需工作
    friend class boost::serialization::access;

    template<class Archive>
    void serialize(Archive& ar, const unsigned int version) {
        ar & _pair;
    }
};
// 如果是抽象基类，还需要
// #include <boost/serialization/assume_abstract.hpp
// BOOST_SERIALIZATION_ASSUME_ABSTRACT(Event)
BOOST_CLASS_EXPORT_KEY(A)

#endif // __A_H__

A.cpp

#include <boost/serialization/export.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include "A.h"
BOOST_CLASS_EXPORT_IMPLEMENT(A)

A::A(int a, int b) {
    _pair = std::make_pair(a, b);
}

B类

B.h

#ifndef __B_H__
#define __B_H__

#include "A.h"
#include <vector>
#include <memory>
#include <boost/serialization/utility.hpp>
// 必须包含用到的STL容器
#include <boost/serialization/vector.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>


class B : public A {
public:
    B() : A(0, 0) {}
    B(int a, int b) : A(a, b) {}

private:
    std::vector<std::shared_ptr<A>> _vector;

private:
    // 派生序列化所需工作
    friend class boost::serialization::access;

    template<class Archive>
    void serialize(Archive& ar, const unsigned int version) {
        // 派生类必须先序列化基类
        ar & boost::serialization::base_object<A>(*this);
        ar & _vector;
    }
};

BOOST_CLASS_EXPORT_KEY(B)

#endif // __B_H__

B.cpp

// 派生类的实现文件必须写上这些
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include "B.h"
BOOST_CLASS_EXPORT_IMPLEMENT(B)

C类

C.h

#ifndef __C_H__
#define __C_H__

#include "A.h"
#include <map>
#include <boost/serialization/utility.hpp>
// 必须包含用到的STL容器
#include <boost/serialization/map.hpp>
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>

class C : public A {
public:
    C() : A(1, 1) {}
    C(int a, int b) : A(a, b), _c(a), _d(b) {}

private:
    std::map<int, std::string> _map;
    int _c;
    int _d;

private:
    // 序列化与反序列化的分离
    friend class boost::serialization::access;

    template<class Archive>
    void save(Archive & ar, const unsigned int version) const {
        // 先save基类，注意模板参数为const A
        ar << boost::serialization::base_object<const A>(*this);
        int c = _c + 1;
        ar << c;
    }

    template<class Archive>
    void load(Archive & ar, const unsigned int version) {
        // 先load基类，注意模板参数为A
        ar >> boost::serialization::base_object<A>(*this);
        ar >> _c;
    }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
        // 告知要分开序列化与反序列化
        boost::serialization::split_member(ar, *this, version);
        // 序列化save和load行为一致的成员
        ar & _map;
        ar & _d;
    }
};

BOOST_CLASS_EXPORT_KEY(C)

#endif // __C_H__

C.cpp

// 派生类的实现文件必须写上这些
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include "C.h"
BOOST_CLASS_EXPORT_IMPLEMENT(C)

main

#include <iostream>
#include <string>
#include <fstream>
#include "B.h"
#include "C.h"
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
using namespace std;

int main() {
    B b;
    C c(1, 2);

    std::ofstream ofile("file.dat");
    if (ofile.is_open()) {
        boost::archive::binary_oarchive oa(ofile);
        oa << b << c;
    }
    ofile.close();

    std::ifstream ifile("file.dat");
    if (ifile.is_open()) {
        try {
            boost::archive::binary_iarchive ia(ifile);
            ia >> b >> c;
        }
        catch (const std::exception&) {
            // 输入流错误
        }
    }
    ifile.close();
    return system("pause");
}

注意点

• 所有使用BOOST_CLASS_EXPORT_*的地方都要包含所使用到的archive头文件。