1

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

#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 成员的错误。

4

1 回答 1

0

澄清问题发生的原因：
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& 到 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;
}
于 2010-09-14T22:44:43.917 回答