registro polimórfico de serialização Boost (exportação) não funciona nos arquiv

Estou usandoboost::serialization no meu projeto. O projeto é grande e serializa meus objetos em vários lugares. De acordo com documentação aqui, Devo exportar minha turma com duas etapas separada

BOOST_EXPORT_KEY() dentro.h file, que contém a declaraçãBOOST_EXPOET_IMPLEMENT() dentro.cpp, que contém a instanciação (definição) da exportaçã

hier.h na hierarquia de classes, existem 3 classes na hierarqui

/*
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);

Ehier.cpp contém a implementação:

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

BOOST_CLASS_EXPORT_IMPLEMENT(D1);
BOOST_CLASS_EXPORT_IMPLEMENT(D2);

Emain.cpp use a serialização:

#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;                                                                                                                                                                                              
}

Compilou sem nenhum problema, mas executá-lo causará:

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

O que significa que a classe derivada não está registrada, significa o registro nohier.cpp não está funcionando. Mas isso é realmente estranho, porque:

Se eu registrar a implementação é tantomain.cpp ehier.cpp, emite definição duplicada ao vincular. Significa o registro emhier.cpp está OK e é exposto à visibilidade dos vinculadore, caso contrário, não haverá erro de definição duplicad

Se eu registrar a implementação apenas emmain.cpp, funciona OK.

Estou realmente confuso nessa situação. Qualquer comentário e sugestão é apreciada. Desde já, obrigado

questionAnswers(1)

yourAnswerToTheQuestion