C++ Boost:：serialization和Boost:：mpi通过基类指针广播派生类

我试图使用boost:：mpi:：broadcast通过基类指针向所有节点发送派生类。为此，我使用boost:：serialization库来序列化我的类。但是，我的代码没有编译，并且出现错误“类boost:：mpi:：packed_skeleton_iarchive”没有名为“append”的成员，“类boost:：mpi:：packed_skeleton_iarchive”没有名为“reset”的成员。”

以下是该程序的大致源代码：

// Base.hpp
#include <boost/serialization/serialization.hpp>

class Base
{
    public:
        Base() {}
        virtual ~Base() {}

        virtual void foo() = 0;
    private:
        friend class boost::serialization::access;

        template<class Archive>
        void serialize( Archive& /*ar*/, const unsigned int /*version*/ ) {}
}

// Derived.hpp
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#include <boost/shared_ptr.hpp>
#include <vector>

#include "Base.hpp"

class Derived : public Base
{
    public:
        Derived( int param );
        virtual ~Derived();

        void foo();
    private:
        int param_;
        std::vector< boost::shared_ptr > bar_;

        friend class boost::serialization::access;

        template<class Archive>
        void serialize( Archive& ar, const unsigned int /*version*/ )
        {
            ar & param_;
            ar & bar_;

            ar & boost::serialization::base_object< Base >( *this );
        }
}

namespace boost
{
    namespace serialization
    {
        template<class Archive>
        void load_construct_data( Archive& /*ar*/, Derived* d,
            const unsigned int /*v*/ )
        {
            ::new(d) Derived( 0 );
        }
    }
}

BOOST_CLASS_EXPORT_KEY( Derived )

// Derived.cpp
#include "Derived.hpp"

Derived::Derived( int param ) : param_( param ) {}
Derived::~Derived(){}

Derived::foo()
{
    // some stuff
}

BOOST_CLASS_EXPORT_IMPLEMENT( Derived )

// Main.cpp
#include <boost/mpi.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/shared_ptr.hpp>

#include "Derived.hpp"

int main( int argc, char* argv[] )
{
    boost::shared_ptr< Base > sp;

    if ( world.rank() == 0 )
    {
        sp = boost::shared_ptr< Base >( new Derived( 5 ) );

        boost::mpi::broadcast( world, sp, 0 );

        // produce some stuff
    } else
    {
        while ( 1 )
        {
           // consume some stuff
        }
    }

    return 0;
}

BOOST_SERIALIZATION_ASSUME_ABSTRACT( Base )

//Base.hpp
#包括
阶级基础
{
公众：
Base（）{}
虚拟~Base（）{}
虚拟void foo（）=0；
私人：
好友类boost:：serialization:：access；
模板
void序列化（存档&/*ar*/，常量unsigned int/*version*/）{}
}
//1.hpp
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括“Base.hpp”
派生类：公共基
{
公众：
派生（int参数）；
虚拟~派生（）；
void foo（）；
私人：
int参数；
标准：：矢量bar；
好友类boost:：serialization:：access；
模板
void序列化（存档&ar，常量unsigned int/*版本*/）
{
ar¶m；
应收账款和应收账款；
ar&boost:：serialization:：base_object（*this）；
}
}
名称空间提升
{
命名空间序列化
{
模板
无效加载构造数据（归档文件&/*ar*/，导出*d，
常量无符号int/*v*/）
{
：：新（d）派生（0）；
}
}
}
BOOST\u类\u导出\u密钥（派生）
//导出的.cpp
#包括“派生的.hpp”
派生：：派生（int-param）：param（param）{}
派生：：~派生（）{}
派生：：foo（）
{
//一些东西
}
BOOST\u类\u导出\u工具（派生）
//Main.cpp
#包括
#包括
#包括
#包括“派生的.hpp”
int main（int argc，char*argv[]）
{
boost:：shared_ptrsp；
if（world.rank（）==0）
{
sp=boost:：shared_ptr（新派生的（5））；
boost:：mpi:：broadcast（世界，sp，0）；
//生产一些东西
}否则
{
而(1)
{
//吃点东西
}
}
返回0；
}
BOOST\u序列化\u假设\u抽象（基本）

---

我发现只有一个谷歌小组讨论过这个问题，但到目前为止还没有解决方案。我怎样才能编译这个？我正在使用openmpi 1.2.8-17.4、gcc 4.5.1和boost 1.54。

我很幸运地回答了我自己的问题（我想）。boost在与boost:：mpi:：packed_skeleton_iarchive结合使用时，无法正确处理基指针序列化。然后，解决方案是使用另一种归档，例如text\u iarchive/text\u oarchive

例如，要广播：

std::ostringstream oss;
boost::archive::text_oarchive oa(oss);
oa << value;
std::string s = oss.str();
boost::mpi::broadcast(comm, s, root);

std::string s;
boost::mpi::broadcast(comm, s, root);
std::istringstream iss(s);
boost::archive::text_iarchive ia(iss);
ia >> value;