Question

我有以下情况（简化）：

A.H：

#include <boost/serialisation/serialisation.hpp>
class B;
using namespace std; using namespace boost;
class A {
   B *b;
   template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & b; }
};

b.h：

#include <boost/serialisation/serialisation.hpp>
class C;
using namespace std; using namespace boost;
class B {
   C *c;
   template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & c; }
};

c.h：

#include <boost/serialisation/serialisation.hpp>
using namespace std; using namespace boost;
class C {
   int somevar;
   template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & somevar; }
};

main.cxx：

#include <boost/archive/text_oarchive.hpp>
#include <fstream>
#include "a.h"
#include "b.h"
#include "c.h"
using namespace std; using namespace boost;

int main() {
   A a; // Create the object

   ofstream ofs("save");
   archive::text_oarchive oa(ofs);

   oa << a; // Save the object

   return 0;
}

现在，问题是我必须在保存函数中包含我想要序列化的所有类的头文件（在这种情况下，在main内部）。问题在于，有三个以上的类，并且它们要复杂得多，导致此时出现编译瓶颈。

我最近才开始使用boost序列化，但我查看了文档并在google和这里进行了搜索，所以我觉得我错过了一些明显的东西。

有没有人有这样的解决方案，只需要包含“a.h”而不是“b.h”，“c.h”等？

编辑：如果我注释掉#include“b.h”和“c.h”行，这有希望成为编译错误的关键部分：

main.cxx:17:1:   instantiated from here
/usr/include/boost/type_traits/is_abstract.hpp:72:4: error: incomplete type ‘B’ not allowed

Answer 1

我认为您可以使用显式实例化，然后在.cpp文件中定义序列化成员函数。然后a.cpp可以根据需要包含b.h和c.h，而a.h的用户不再需要这样做了。

查看pimpl-idiom示例http://www.boost.org/doc/libs/1_46_1/libs/serialization/example/demo_pimpl_A.hpp（标题）和http://www.boost.org/doc/libs/1_46_1/libs/serialization/example/demo_pimpl_A.cpp（源文件），了解如何执行此操作。

Answer 2

免责声明：我对升级序列化一无所知。

由于您的模板成员函数serialize必须具有使用成员的内联定义，因此您应该#include这些成员的头文件，而不是仅仅声明class B;

这意味着main只需要#include "a.h"在main中，你就不会遇到编译错误。

Answer 3

首先，如果有一个方法，任何方法，需要访问A，B和C，除了使A，B和C可见之外别无他法。方法，并且在yur的情况下，tha表示包括所有3个头文件。所以你谈到的编译器瓶颈无法解决。

其次，您应该能够使用非侵入性功能进行Boost的序列化。不确定这是否能解决您的特定问题，但绝对值得一试，它确实将所有与序列化相关的内容移动到一个单独的头文件中。

  //header myserialization.h
#include "a.h"
#include "b.h"
#include "c.h"

template<class Archive>
void serialize(Archive & ar, const unsigned int version, A& a) { ar & a.*b; }

template<class Archive>
void serialize(Archive & ar, const unsigned int version, B& b) { ar & b.*c; }

template<class Archive>
void serialize(Archive & ar, const unsigned int version, C& c) { ar & c.somevar; }

如何避免包含需要进行BOOST序列化的每个类的标头？

3 个答案: