C++ 如何在Boost序列化中创建序列化接口？

我是新手，我想实现一个接口来强制用户实现序列化方法。这个方法是模板，我不能定义为虚拟的

我希望用户只需实现如下功能：

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

但是它强制用户实现这两种方法，这不是我想要的

有什么办法可以满足我的要求吗

---

谢谢你

没有内置的方法，但是你当然可以通过适当的权衡来抽象任何你想要的界面

这里有一个设想中的解决方案，它使用了一个自定义的

多拱

，可以作为

多态性拱

或

多态性拱

的参考：

#include <boost/serialization/serialization.hpp>
#include <boost/archive/polymorphic_oarchive.hpp>
#include <boost/archive/polymorphic_iarchive.hpp>
#include <boost/archive/polymorphic_text_oarchive.hpp>
#include <boost/archive/polymorphic_text_iarchive.hpp>
#include <boost/variant.hpp>
#include <sstream>

using PolyArchive = boost::variant<
            boost::archive::polymorphic_oarchive&,
            boost::archive::polymorphic_iarchive&
        >;

struct /*abstract*/ ISerializable {
    virtual void serialize(PolyArchive, unsigned) = 0;
};

struct MyClass : ISerializable {
    std::string data_member = "Morgana"; // something to serialize

    // the one method we need to implement
    virtual void serialize(PolyArchive ar, unsigned) override;
};

精明的读者会发现，用户仍然提供模板方法，但将其隐藏在一个虚拟方法中，该方法在编译时实际采用

多拱结构

完整演示
请参见打印：

Serialized: 22 serialization::archive 11 0 0 7 Morgana
Roundtripped: 22 serialization::archive 11 0 0 7 Morgana

代码：

#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用PolyArchive=boost:：variant<
boost:：archive:：多态的，
boost:：archive:：多态的&
>;
struct/*abstract*/ISerializable{
虚空序列化（多拱形，无符号）=0；
};
结构MyClass:ISerializable{
std:：string data_member=“Morgana”//要序列化的内容
//我们需要实现的一种方法
虚空序列化（多拱形ar，无符号）重写；
};
int main（）
{
std：：stringstream-ss；
{
//序列化：
boost:：archive:：多态文本输出（ss）；
MyClass对象；
输出
void MyClass::serialize(PolyArchive ar, unsigned) {
    boost::apply_visitor(make_visitor([=](auto& ar) { 
            ar & data_member;
        }), ar);
}

Serialized: 22 serialization::archive 11 0 0 7 Morgana
Roundtripped: 22 serialization::archive 11 0 0 7 Morgana

#include <boost/serialization/serialization.hpp>
#include <boost/archive/polymorphic_oarchive.hpp>
#include <boost/archive/polymorphic_iarchive.hpp>
#include <boost/archive/polymorphic_text_oarchive.hpp>
#include <boost/archive/polymorphic_text_iarchive.hpp>
#include <boost/variant.hpp>
#include <sstream>

using PolyArchive = boost::variant<
            boost::archive::polymorphic_oarchive&,
            boost::archive::polymorphic_iarchive&
        >;

struct /*abstract*/ ISerializable {
    virtual void serialize(PolyArchive, unsigned) = 0;
};

struct MyClass : ISerializable {
    std::string data_member = "Morgana"; // something to serialize

    // the one method we need to implement
    virtual void serialize(PolyArchive ar, unsigned) override;
};

int main()
{
    std::stringstream ss;
    {
        // serialize:
        boost::archive::polymorphic_text_oarchive output(ss);

        MyClass object;
        output << object;
    }

    // Debug dump;
    std::cout << "Serialized: " << ss.str();

    {
        // read back:
        boost::archive::polymorphic_text_iarchive input(ss);

        MyClass cloned;
        input >> cloned;

        std::cout << "Roundtripped: ";
        boost::archive::polymorphic_text_oarchive pta(std::cout);
        pta << cloned;
    }
}

////////////////////////////////
// implementation:

namespace /*detail*/ {
    template <typename F> struct wrap_visitor : boost::static_visitor<> {

        wrap_visitor(F const& f) : f_(f) { }
        wrap_visitor(F&& f)      : f_(std::move(f)) { }

        template<typename... T> void operator()(T&&... t) const {
            f_(std::forward<T>(t)...);
        }

    private:
        F f_;
    };

    template <typename F> 
    wrap_visitor<F> make_visitor(F&& f) {
        return std::forward<F>(f);
    }
}

void MyClass::serialize(PolyArchive ar, unsigned) {

    boost::apply_visitor(make_visitor([=](auto& ar) { 
            ar & data_member;
        }), ar);
}