c++ - 如何在没有类枚举器的情况下反序列化类层次结构

我正在使用这种方法来序列化和反序列化类层次结构:

 // Enumeration of classes.
 struct Type {
     enum TypeEnum { A, B }
     TypeEnum t;
     Type(TypeEnum te) : t(te) { }
     bool operator == (TypeEnum te);
     void saveToStream(Stream& stream);
     void loadFromStream(Stream& stream);
 };

 // Serializable base class.
 struct A {
     Type type;
     A() { type = Type::A; }
     // ... members
     virtual void loadFromStream(Stream& stream);
     virtual void saveToStream(Stream& stream) const;
 };

 // Serializable child class.
 struct B : public A {
     B() : A() { type = Type::B; }
     virtual void loadFromStream(Stream& stream);
     virtual void saveToStream(Stream& stream);
 };

 // Helper class.
 struct Serializer {
     static A* loadFromStream(Stream& stream)
     {
        Type t;
        t.loadFromStream(stream);
        if (t == Type::A) {
           A* a = new A;
           a->loadFromStream(stream);
           return a;
        } else if (t == Type::B) {
           A* b = new B;
           b->loadFromStream(stream);
           return b;
        }
        throw "Unknown type";
        return 0; // surpress warning
     }
     static void saveToStream(Stream& stream, const A& a)
     {
        a.type.saveToStream(stream);
        a.saveToStream(stream);
     }
 };

 // Usage
 B b;
 Serializer::saveToStream(stream, b);
 B* b2 = static_cast<B*>(Serializer::loadFromStream(stream));

这种方法非常简单易懂。但是我在考虑是否有一种更优雅的解决方案，而无需在每次扩展类层次结构时都更新Type类。

如果没有枚举器类Type甚至没有Serializer类，您是否有任何提示？

最佳答案

这似乎是Factory Pattern的不错候选人。

基本上，它包括委派基于给定标识符实例化正确类型的职责。在Stack Overflow上进行的搜索显示了this answer，它提供了一个用C++实现的很好的例子。请注意，工厂可以创建的所有对象都必须实现一个公共(public)接口(interface)(这似乎是您的情况)。

一旦实现了这种模式，就可以删除if中的else if / Serializer::loadFromStream级联，而只需在工厂实例化对象上调用loadFromStream。

关于c++ - 如何在没有类枚举器的情况下反序列化类层次结构，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/4240138/