c++ - boost.serialization - 免费版本和基类实现

Question

我有一个基本上构造其子类的“生成器”类。要使用这个东西，我只需将它子类化并传递给它正确的参数来构建我想要构建的对象。我想序列化这些东西，没有充分的理由为每个子类都这样做，因为所有数据都在基础中。这是我得到的示例:

#include <boost/serialization/serialization.hpp>
template < typename T >
struct test_base
{
  // works...
  //template < typename Archive >
  //void serialize(Archive &, unsigned int const)
 // {
  //}
};

template < typename T >
void f(test_base<T> const&) {}

struct test_derived : test_base<int>
{
};

namespace boost { namespace serialization {

template < typename Archive, typename T >
void serialize(Archive &, test_base<T> &, unsigned int const)
{
}

}}

#include <boost/archive/binary_oarchive.hpp>
#include <sstream>
int main()
{
  int x = 5;
  test_derived d;
  //boost::serialization::serialize(x, d, 54); // <- works.

  std::ostringstream str;
  boost::archive::binary_oarchive out(str);
  out & d; // no worky.
}

如果可能的话，我希望免费版本能够运行。是吗？

上面的版本会吐出关于序列化不是 test_derived 成员的错误。

Answer 1

澄清问题发生的原因:
boost::serialization 必须有实现序列化功能的方法。作为类方法或(在您的情况下)在 boost::serialization 命名空间中定义函数的非侵入式方式。
所以编译器必须以某种方式决定选择哪个实现。出于这个原因，boost 有一个 boost::serialization::serialize 模板函数的“默认”实现。
签名:

template<class Archive, class T>
inline void serialize(Archive & ar, T & t, const BOOST_PFTO unsigned int file_version)

在该函数中有一个对 T::serialize(...) 的调用。因此，当您不想要侵入式版本时，您必须使用比默认函数模板更明确的内容来覆盖 boost::serialization::serialize 函数。
现在的问题是:
在你的情况下，编译器必须决定它是否
a) 选择必须隐式转换参数的版本(test_derived& to test_base&)
b) 使用通用函数而不进行转换(T 是 test_derived&)
您希望编译器使用变体 a) 但编译器更喜欢 b)

解决方案:
我不知道一个真正好的解决方案。我想我会使用一个宏来生成具有显式类型的 serialize(...) 的实现。
如果这不是您的可能解决方案，您还可以更明确地告诉编译器调用什么:

out & *((test_base<int>*)&d);

并将其包装在一些辅助函数中(因为没有人愿意整天看这样的代码)

我希望这是一个清晰的描述并且对您有所帮助

如果我的解释不清楚，这里有一个例子:

#include <iostream>
class Base
{
public:
    virtual ~Base()
    {
    }
};

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


void foo(Base& bar)
{
    std::cout << "special" << std::endl;
}

template<typename T>
void foo(T& bar)
{
    std::cout << "generic" << std::endl;
}

int main()
{
    Derived derived;
    foo(derived);         // => call to generic implementation
    foo(*((Base*) &bla)); // => call to special 
    return 0;
}