将继承对象强制转换为正确子类的最佳实践

Question

我有两个班，每个班都有几个孩子：

class ContainerGeneral {...};
class ContainerTypeA : ContainerGeneral {
public:
    void doSomethingA();
};
class ContainerTypeB : ContainerGeneral {
    void doSomethingB();
};

class InterpreterGeneral {
protected:
    ContainerGeneral* container;
};

class InterpreterTypeA : InterpreterGeneral {
public:
    void saveContainer(ContainerTypeA* cont) {
        container = cont;
    }
};

class InterpreterTypeB : InterpreterGeneral {
public:
    void saveContainer(ContainerTypeB* cont) {
        container = cont;
    }
};

Interpreter 类用于对应类型的容器（A 到 A、B 到 B、General 到 General）。为此，我向InterpreterGeneral 添加了一个指向ContainerGeneral 对象的成员指针。我希望InterpreterGeneral 将此对象寻址为ContainerGeneral，但我希望继承的类能够将相同的容器寻址为适当类型的容器。我可以通过在寻址时将指针转换为继承的类来做到这一点（仅用于A 以节省空间的示例）：

(ContainerTypeA*)container->doSomethingA();

或者通过添加一个继承类型的新成员指针，该指针将指向与容器相同的位置：

class InterpreterTypeA : InterpreterGeneral {
public:
    void saveContainer(ContainerTypeA* cont) {
        containerA = cont;
        container = cont;
    }
    void doSomething() {
        containerA->doSomethingA();
    }
private:
    ContainerTypeA* containerA;
};

在这种情况下，最佳做法是什么？有没有办法尽可能干净地做到这一点，无需每次都进行强制转换，也无需添加不包含任何“新”信息的新成员？

Answer 1

如果您需要有关InterpreterTypeA 和InterpreterTypeB 中容器实例的具体类型信息，请在您的代码中通过不在GeneralInterpreter 中存储GeneralContainer* 数据成员来表达这一点（protected 数据成员在任何情况下），而是具体的ContainerTypeA* 和ContainerTypeB* 子类InterpreterTypeA 和InterpreterTypeB 中的数据成员。存储一个基类指针然后通过强制转换来规避它的限制隐藏了需要具体类型信息的事实。

此外，在容器基类中提供doSomethingA()和doSomethingB()的空默认实现，或者将它们转换为virtual纯成员函数并将空实现转换为ContainerTypeA和ContainerTypeB。然后，调用它们是安全的——当它是不受欢迎的具体类型时，它们不会做任何事情。

最后一个迂腐的旁注：我看不出有任何理由在层次结构“子”类中调用派生类。常用术语是“子”类。

Answer 2

您正在处理的问题有virtual functions 形式的解决方案。试试这个：

class ContainerGeneral {
public:
    virtual void doSomething() = 0;
};

class ContainerTypeA : public ContainerGeneral {
public:
    void doSomething() {
        std::cout << "Hello A!" << std::endl;
    };
};

class ContainerTypeB : public ContainerGeneral {
public:
    void doSomething() {
        std::cout << "Hello B!" << std::endl;
    };
};

这样你就完全不用费心从InterpreterGeneral继承了：

class InterpreterGeneral {
public:
    void doSomething()
    {
        container->doSomething();
    }
private:
    ContainerGeneral* container;
};

旁注：这当然会产生一些运行时开销。如果您在运行时不需要多态性，则可以避免它。看看the static polymorphism。仅当您是忍者时。