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));

//类的枚举。
结构类型{
枚举类型枚举{A，B}
类型枚举t；
类型（typeenumte）：t（te）{
布尔运算符==（类型枚举te）；
void saveToStream（流和流）；
流中的无效荷载（流和流）；
};
//可序列化基类。
结构A{
类型；
A（）{type=type:：A；}
//……成员
虚拟void loadFromStream（Stream&Stream）；
虚拟空存储流（流和流）常量；
};
//可序列化的子类。
结构B：公共A{
B（）：A（）{type=type:：B；}
虚拟void loadFromStream（Stream&Stream）；
虚拟void saveToStream（流和流）；
};
//助手类。
结构序列化程序{
静态A*loadFromStream（流和流）
{
t型；
t、 loadFromStream（stream）；
if（t==Type:：A）{
A*A=新的A；
a->loadFromStream（流）；
返回a；
}else if（t==类型：：B）{
A*b=新的b；
b->loadFromStream（stream）；
返回b；
} 
抛出“未知类型”；
返回0；//意外警告
}
静态无效saveToStream（流和流，常量A和A）
{
a、 类型.saveToStream（流）；
a、 saveToStream（流）；
}
}; 
//用法
B B；
序列化程序：：saveToStream（流，b）；
B*b2=静态_转换（序列化程序：：loadFromStream（流））；

这种方法非常简单明了。但是我在考虑是否有一个更优雅的解决方案，而不需要每次扩展类层次结构时更新class

Type

---

您是否有任何提示，说明如何在没有枚举器类

Type

和可能没有类

序列化器的情况下执行此操作
 这似乎是一个很好的候选人

基本上，它包括根据给定的标识符委派实例化正确类型的职责。对堆栈溢出的查找，为C++实现提供了一个很好的例子。请注意，工厂可以创建的所有对象都必须实现一个公共接口（这似乎是您的情况）

一旦您实现了这种模式，您就可以删除
if
/
else if
在
Serializer:：loadFromStream
中的级联，只需在工厂实例化的对象上调用
loadFromStream
。
嗯，是的，这是有可能的。您可以进行静态和动态注册，但实现实际上取决于您要将其放置在何处。它可以驻留在构建系统中，可以使用宏/模板元程序生成，甚至可以是动态的.查看提供的示例，我相信
if/else if
级联是一种更直接的方法，更容易理解。