Boost序列化多态寄存器（导出）无法跨文件工作

我正在项目中使用

boost:：serialization

。这个项目很大，在几个地方序列化了我的对象。根据，我应该用两个分开的步骤导出我的类

BOOST\u EXPORT\u KEY（）

在

.h

文件中，其中包含声明

.cpp

文件中的

BOOST\u expoot\u IMPLEMENT（）

，其中包含导出的实例化（定义）

hier.h

class层次结构中有3个类

/*
B <---+--- D1
      |
      +--- D2
*/

#include <boost/serialization/base_object.hpp>                                                                                                                                                                 

class B {                                                                                                                                                                                                      
public:                                                                                                                                                                                                        
    virtual ~B() {}                                                                                                                                                                                            
    template < typename Ar >                                                                                                                                                                                   
    void serialize(Ar& ar, const int) {                                                                                                                                                                        
    }                                                                                                                                                                                                          
} ;                                                                                                                                                                                                            

class D1 : public B {                                                                                                                                                                                          
public:                                                                                                                                                                                                        
    virtual ~D1() {}                                                                                                                                                                                           
    template < typename Ar > void serialize(Ar& ar, const int) {                                                                                                                                               
        boost::serialization::base_object<B>(*this);                                                                                                                                                           
    }                                                                                                                                                                                                          
} ;                                                                                                                                                                                                            

class D2 : public B {                                                                                                                                                                                          
public:                                                                                                                                                                                                        
    template < typename Ar > void serialize(Ar& ar, const int) {                                                                                                                                               
        boost::serialization::base_object<B>(*this);                                                                                                                                                           
    }                                                                                                                                                                                                          
    virtual ~D2() {}                                                                                                                                                                                           
} ;                                                                                                                                                                                                            

#include <boost/serialization/export.hpp>                                                                                                                                                                      

BOOST_CLASS_EXPORT_KEY(B);                                                                                                                                                                                     
BOOST_CLASS_EXPORT_KEY(D1);                                                                                                                                                                                    
BOOST_CLASS_EXPORT_KEY(D2);

和

main.cpp

使用序列化：

#include <iostream>                                                                                                                                                                                            
#include <sstream>                                                                                                                                                                                             
#include <boost/archive/text_iarchive.hpp>                                                                                                                                                                     
#include <boost/archive/text_oarchive.hpp>                                                                                                                                                                     
#include <boost/serialization/export.hpp>                                                                                                                                                                      
#include "hier.h"                                                                                                                                                                                              

int main(int argc, char* argv[])                                                                                                                                                                               
{                                                                                                                                                                                                              
    B* d1 = new D1();                                                                                                                                                                                          
    B* d2 = new D2();                                                                                                                                                                                          
    std::ostringstream os;                                                                                                                                                                                     
    boost::archive::text_oarchive oa (os);                                                                                                                                                                     
    oa & d1 & d2;                                                                                                                                                                                              
}

这意味着派生类未注册，意味着

hier.cpp

中的注册无效。但这真的很奇怪，因为：

如果我注册的实现同时是

main.cpp

和

hier.cpp

，它在链接时会发出重复的定义表示在

hier.cpp

中的注册正常，并显示在链接器可见性中。，否则将不会出现重复的定义错误

如果我只在

main.cpp

中注册实现，它运行正常

---

在那种情况下我真的很困惑。如有任何意见和建议，我们将不胜感激。提前谢谢

在调用

BOOST\u CLASS\u EXPORT.*

之前，您应该包括您想要使用的归档文件。makro然后为标头添加特定的序列化函数

这意味着您应该将

hier.cpp

中的代码更改为以下内容：

#include <boost/serialization/export.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include "hier.h"

BOOST_CLASS_EXPORT_IMPLEMENT(D1);
BOOST_CLASS_EXPORT_IMPLEMENT(D2);

资料来源：

附言：

---

我不知道这是否解决了你的问题，但我认为这可能会引起一些麻烦。我认为值得一试。

这是迄今为止我发现的有关Boost序列化的最清晰、最有用的问题和答案。与Boost的许多其他文档一样，序列化文档是一个信息的漫游泥潭，这个简单的示例非常简洁，帮助我解决了这个问题。做得好！

terminate called after throwing an instance of 'boost::archive::archive_exception'
  what():  unregistered class - derived class not registered or exported

#include <boost/serialization/export.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include "hier.h"

BOOST_CLASS_EXPORT_IMPLEMENT(D1);
BOOST_CLASS_EXPORT_IMPLEMENT(D2);

#include <boost/serialization/export.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>

BOOST_CLASS_EXPORT_KEY(B);
BOOST_CLASS_EXPORT_KEY(D1);
BOOST_CLASS_EXPORT_KEY(D2);