多重继承和数据成员

Question

我从未使用过多重继承，并偶然发现了一个我从未遇到过的设计问题..

class A {
     //..methods..
}

class B : public A {
    int b;
    //...methods..
}

class C : public A {
    int c1,c2;
}

class D : public B,public C {
}

这是经典的钻石。事实上，C 实际上只是一个带有两个额外整数的A。 D 实际上只是 B 和 C 的聚合，但我觉得多重继承并不是为了制造这样的东西而设计的。或者可能有其他最佳做法可以做到这一点。

我尝试实现多重继承的原因是我想编写一个类似void func(A*) 的函数并将其传递给A 或D 类指针。我的天真的尝试是做一个简单的演员表：

void func(A* a) { // <-- I call this with a A or D pointer
   // ..do something with A members..

    if(is_the_case) { // <-- Im sure the passed "a" pointer is actually a *D
        D* d = (D*)a;
       // ..do something with the extra 2 ints provided by the C class..
    } 
}

不起作用.. 编译得很好，但是当 if(is_the_case) 被执行时我有一个非常奇怪的行为，清除了 2 个额外的整数 c1 和 c2，也清除了 b（由 B 继承)。

我想起了钻石问题，但这里的层次结构中只有一个B（和两个A），所以我不明白为什么b 也会被清除。为了尝试，我在B 和C 声明中使用了公共虚拟。现在每次转换都是编译错误，除非我使用dynamic_cast..

有人能说清楚幕后发生的事情吗？考虑到还有其他课程，例如：

class E : public A {
    int e;
    //..methods..
}

class F : public E,public C {
}

也就是说，其他类只是从 A 派生的类的聚合 + 由 C 继承的两个额外整数，并且可以传递给采用 *A 的函数

谢谢，我尽量说清楚了..

Answer 1

您的代码可以正常工作，因为您使用了 C 风格的转换，可以是 reinterpret_cast，我的理解是您可以在任何两种指针类型之间使用 reinterpret_cast，即使它没有意义。从多重继承的基类转换为更派生的类时，您必须使用dynamic_cast。 static_cast 会产生编译时错误。事实上，dynamic_cast 同时完成了这两项工作。

void func(A* a) { // <-- I call this with a A or D pointer
   // ..do something with A members..

    if(D* d = dynamic_cast<D*>(a)) { // a definitely points to a D
        // and we got a guaranteed good pointer too
    } 
}

这是一个很好的例子，说明了为什么应该避免 C 风格的强制转换。

Answer 2

您可以阅读有关多重继承的信息here。

你需要做的是虚拟继承下一个类：

class B : virtual public A {
    int b;
    //...methods..
};

class C : virtual public A {
    int c1,c2;
};

Answer 3

我不知道您为什么会看到这种行为。如 cmets 中所述，您所描述的代码不应编译。

是否存在设计问题？是的。不要根据查询对象的类型明确做出选择。这就是虚函数的用途。

class A
{
public:
    virtual void prepare_for_list_insertion() {}
};

class B : public A
{
    int b;
};

class C : public A
{
private:
    int c1, c2;

protected:
    void clear() { c1 = c2 = 0; }
};

class D : public B, public C
{
public:
    void prepare_for_list_insertion()
    {
        clear();
    }
};

void func(A* a)
{
    a->prepare_for_list_insertion();
}

int main()
{
    A a;
    func(&a); // calls A::prepare_for_list_insertion
    D d;
    // You need a cast to disambiguate the A base - either will do.
    func(static_cast<C*>(&d)); // calls D::prepare_for_list_insertion
    func(static_cast<B*>(&d)); // calls D::prepare_for_list_insertion
}