打开对象实际类型的正确方法是什么

您是否考虑过在这里使用多态性？ 如果每个具体类都可以实现一个通用接口，那么所有这些代码都会消失，将来事情变得简单易变。 例如：

class Camera {
public:
    virtual void Init() = 0;
    virtual void TakeSnapshot() = 0;
}
class KodakCamera : Camera {
public:
    void Init() { /* initialize a Kodak camera */ };
    void TakeSnapshot() { std::cout << "Kodak snapshot"; }
}
class SonyCamera : Camera {
public:
    void Init() { /* initialize a Sony camera */ };
    void TakeSnapshot() { std::cout << "Sony snapshot"; }
}

因此，假设我们有一个包含硬件设备的系统，在本例中为相机。 每个设备都需要不同的逻辑来拍照，但代码必须支持具有任何支持相机的系统，因此我们不希望 switch 语句散落在我们的代码中。 因此，我们创建了一个抽象类Camera。

每个具体的类（即SonyCamera、KodakCamera）实现将包含不同的标头，链接到不同的库等，但它们都共享一个通用接口;我们只需要决定预先创建哪一个。 所以。。。

std::unique_ptr<Camera> InitCamera(CameraType type) {
    std::unique_ptr<Camera> ret;
    Camera *cam;
    switch(type) {
    case Kodak:
        cam = new KodakCamera();
        break;
    case Sony:
        cam = new SonyCamera();
        break;
    default:
        // throw an error, whatever
        return;
    }
    ret.reset(cam);
    ret->Init();
    return ret;
}
int main(...) {
    // get system camera type
    std::unique_ptr<Camera> cam = InitCamera(cameraType);
    // now we can call cam->TakeSnapshot 
    // and know that the correct version will be called.
}

所以现在我们有一个具体的实例来实现Camera . 我们可以调用TakeSnapshot而无需在代码中的任何位置检查正确的类型，因为这无关紧要;我们知道将调用正确硬件的正确版本。 希望这有帮助。

根据您在下面的评论：

我一直在尝试使用多态性，但我认为元素差异太大。例如，E_SessionTip有一个金额和状态元素，而E_Url只有一个 url。我可以在属性系统下统一它，但随后我完全失去了所有漂亮的打字。如果您知道这种方法可以工作，我愿意接受建议。

我建议将写入 XML 数据的责任传递给共享公共接口的类型。 例如，而不是这样的东西：

void WriteXml(Entity *entity) {
   switch(/* type of entity */) {
      // get data from entity depending
      // on its type and format
   }
   // write data to XML
}

做这样的事情：

class SomeEntity : EntityBase {
public:
    void WriteToXml(XmlStream &stream) {
        // write xml to the data stream.
        // the entity knows how to do this,
        // you don't have to worry about what data
        // there is to be written from the outside
    }
private:
    // your internal data
}
void WriteXml(Entity *entity) {
    XmlStream str = GetStream();
    entity->WriteToXml(stream);
}

这对你有用吗？ 我以前确实这样做过，它对我有用。 让我知道。

双重调度可能会引起人们的兴趣。表（在您的情况下）将调用基元素的虚拟方法，该方法又会回调到表中。 第二次调用是使用对象的动态类型进行的，因此在 Table 类中找到相应的重载方法。

#include <iostream>
class Table;  //forward declare
class BaseElement
{
public:
   virtual void addTo(Table* t);
};
class DerivedElement1 : public BaseElement
{
   virtual void addTo(Table* t);
};
class DerivedElement2 : public BaseElement
{
   virtual void addTo(Table* t);
};
class Table
{
public:
   void addElement(BaseElement* e){ e->addTo(this); }
   void addSpecific(DerivedElement1* e){ std::cout<<"D1"; } 
   void addSpecific(DerivedElement2* e){ std::cout<<"D2"; } 
   void addSpecific(BaseElement* e){ std::cout<<"B"; } 
};
void BaseElement::addTo(Table* t){ t->addSpecific(this); }
void DerivedElement1::addTo(Table* t){ t->addSpecific(this); }
void DerivedElement2::addTo(Table* t){ t->addSpecific(this); }
int main()
{
Table t;
DerivedElement1 d1;
DerivedElement2 d2;
BaseElement b;
t.addElement(&d1);
t.addElement(&d2);
t.addElement(&b);
}

输出：D1D2B

看看访客模式，它可能会对你有所帮助