从基类到不同派生类的多重继承转换

Question

我有以下一组类：

还有下面这段代码：

A* a;
if(condition)
{
    a = new E();
}
else
{
    a = new D();
}

既然有F::foo()这样的函数，为了调用它，我必须将a转换为E*或D*：

if(condition)
{
    ((E*)a)->foo();
}
else
{
    ((D*)a)->foo();
}

据我所知，将a 转换为F* 以调用F::foo 是非法的，因为a 是A* 类型；对我来说，在调用foo 之前检查条件听起来像是一个设计问题。有人可以就如何改进这个类层次结构提供一些建议吗？

附言用this tool画图。

Answer 1

#include <iostream>

struct A { virtual ~A() {} };

struct C : virtual A {};

struct B : virtual A {};

struct F {
    virtual void Foo() { std::cout << "ok\n"; }
};

struct E : C, virtual F {};

struct D : B, virtual F {};


int main() {
    A *a = new E();
    dynamic_cast<F*>(a)->Foo();
}

• 如果你搞砸了，a 的引用不是F 的实例，那么 dynamic_cast 返回 null
• 如果您不使用虚拟继承，那么您最终可能会得到模棱两可的基类。 dynamic_cast 到一个模棱两可的基础将失败（返回 null）。在此示例中，没有不明确的碱基，但您必须注意这一点。
• 我在大多数类中都省略了虚拟析构函数，但这只是因为我很懒。

如果您反复发现自己处理的对象既是 A 和 F 的实例，那么如果可能，这应该反映在类层次结构中。例如，您可以定义一个类型G，它实际上继承自A 和F。然后D 和E 可以从G 继承而不是F，并且您可以将G* 传递给这个期望A* 可以调用Foo() 的代码。

Answer 2

如果不知道你的类的确切语义，很难给你设计建议（字母只是符号，所以必须假设这些继承关系是正常的，而它们可能不是）。

看看你的模型的正式组织，我会说你可以给A添加一个虚函数，D和E都会覆盖它。然后，这些覆盖会将实现委托给F::foo()。

class A { 
public:
    virtual void bar() { }; // Maybe make this pure if A is abstract
    // ...
};

// ...

class D : public C, public F { 
public:
    virtual void bar() { /* ... */ f::foo(); /* ... */ }
    // ...
};

class E : public B, public F { 
public:
    virtual void bar() { /* ... */ f::foo(); /* ... */ }
    // ...
};

Answer 3

不知道不同类的角色，很难 说，但如果 A 和 F 是接口（可能是这种情况），那么 给出一个A*，正确的方法是询问对象是否也 支持接口F 是dynamic_cast<F*>。这给 您指向F 接口的指针（如果支持），以及 否则为空指针。

除此之外，您可能会反映F 接口是否扩展 A 接口，或者是否完全不相关。如果它 是一个扩展，那么F 应该可能派生自A；什么时候 创建一个已知实现扩展接口的对象， 您将其地址分配给F*，并避免所有未来的演员表。 （一般来说，在达到某个点之前不要分配给A* 其中一些指向的对象将不实现F。） 所以你最终会得到类似的东西：

//  interfaces...
class A {};
class F : public virtual A {};

//  implementations of A...
class C : public virtual A {};
class B : public virtual A {};

//  implementations of F (and also A, of course)
class E : public C, public virtual F {};
class D : public B, public virtual F {};

注意，当从接口派生时，一般是 使推导虚拟化是个好主意。 （在这种情况下，它 A 的所有派生都需要。但由于同样 模式可以在另一个层次上重复，有一些新的类 扩展F的接口，一般来说比较简单 采用规则：从接口派生是虚拟的。）

如果F 真的与A 无关，那么您甚至可能会问什么 一类正在实现两者。或者，如果有意义的话 A 的一些（很多？）实现也实现了F，你 可能会考虑提供对F 的访问作为界面的一部分 A：说一个虚函数F* A::getF() { return NULL; }； 同样实现F 的类将覆盖此函数 类似于F* E::getF() { return this; }。

Answer 4

如果F 只是一个实现细节，那么你应该按照@AndyProwl 所说的去做。在基类A中创建一个虚函数。

如果F不只是一个实现细节，另一种方法是将要处理的对象列表保留为Fs，并将要处理的对象保留为As。同样，正如 Andy 所说，这将取决于您的情况的语义。

vector<F*> effs;
vector<A*> ehs;

A* a;
F* f;
if(condition) {
    E* e = new E();
    a = e;
    f = e;
}
else {
    D* d = new D();
    a = d;
    f = d;
}

effs.push_back(f);
ehs.push_back(a);

for(A* a: ehs) {
    a->bar();
}
for(F* f: effs) {
    f->foo();
}