虚拟继承构造函数的顺序

2018-06-08 20:34:23

我试图更好地理解虚拟继承的概念，它有什么危险。

我读过另一篇文章（为什么默认构造函数在虚拟继承中调用？），它（=虚拟继承）改变了构造函数调用的顺序（“祖母”首先被调用，而没有虚拟继承则不会）。

所以我尝试了以下看法，我得到了这个想法（VS2013）：

#define tracefunc printf(__FUNCTION__); printf("rn")
struct A
{
    A(){ tracefunc; }

};

struct B1 : public A
{
    B1(){ tracefunc; };
};

struct B2 : virtual public A
{
    B2() { tracefunc; };
};

struct C1 : public B1
{
    C1() { tracefunc; };
};

struct C2 : virtual public B2
{
    C2() { tracefunc; };
};

int _tmain(int argc, _TCHAR* argv[])
{
    A* pa1 = new C1();
    A* pa2 = new C2();
}

输出是：

A::A
B1::B1
C1::C1
A::A
B2::B2
C2::C2

这不是我所期望的（我预计这两个班级的顺序会有所不同）。

我错过了什么？有人可以解释或指导我一个更好地解释它的来源吗？

谢谢！

在你的例子中，你的输出是预期的。 Virtual inheritance在实例中发挥作用，当你有一个具有多重继承的类时，父类也从同一类/类型继承（即“钻石问题”）。在你的例子中，你的类可能被设置为虚拟继承（如果在代码的其他地方需要），但是它们不一定基于你的例子“虚拟继承”，因为没有派生类（ B1/B2/C1/C2 ）不仅仅是直接从A继承。

为了扩大，我调整了你的例子来解释一些：

#include <cstdio>

#define tracefunc printf(__FUNCTION__); printf("rn")
struct A
{
    A() { tracefunc; }
    virtual void write() { tracefunc; }
    virtual void read() { tracefunc; }
};

struct B1 : public A
{
    B1() { tracefunc; };
    void read(){ tracefunc; }
};

struct C1 : public A
{
    C1() { tracefunc; };
    void write(){ tracefunc; }
};

struct B2 : virtual public A
{
    B2() { tracefunc; };
    void read(){ tracefunc; }
};

struct C2 : virtual public A
{
    C2() { tracefunc; };
    void write(){ tracefunc; }
};

// Z1 inherits from B1 and C1, both of which inherit from A; when a call is made to any
// of the base function (i.e. A::read or A::write) from the derived class, the call is
// ambiguous since B1 and C1 both have a 'copy' (i.e. vtable) for the A parent class.
struct Z1 : public B1, public C1
{
    Z1() { tracefunc; }
};

// Z2 inherits from B2 and C2, both of which inherit from A virtually; note that Z2 doesn't
// need to inherit virtually from B2 or C2. Since B2 and C2 both virtual inherit from A, when
// they are constructed, only 1 copy of the base A class is made and the vtable pointer info
// is "shared" between the 2 base objects (B2 and C2), and the calls are no longer ambiguous
struct Z2 : public B2, public C2
{
    Z2() { tracefunc; }
};


int _tmain(int argc, _TCHAR* argv[])
{
    // gets 2 "copies" of the 'A' base since 'B1' and 'C1' don't virtually inherit from 'A'
    Z1 z1;
    // gets only 1 "copy" of 'A' base since 'B2' and 'C2' virtualy inherit from 'A' and thus "share" the vtable pointer to the 'A' base
    Z2 z2;

    z1.write(); // ambiguous call to write (which one is it .. B1::write() (since B1 inherits from A) or A::write() ?)
    z1.read(); // ambiguous call to read (which one is it .. C1::read() (since C1 inherits from A) or A::read() ?)

    z2.write(); // not ambiguous: z2.write() calls C2::write() since it's "virtually mapped" to/from A::write() 
    z2.read(); // not ambiguous: z2.read() calls B2::read() since it's "virtually mapped" to/from A::read() 
    return 0;
}

虽然它对于我们打算在z1变量的情况下调用的人来说可能是“显而易见的”，但由于B1没有write方法，所以我会“期待”编译器选择C1::write方法，但由于对象的内存映射是如何工作的，所以会出现问题，因为C1对象中的A的基本副本可能具有与B1对象中A基底的副本不同的信息（指针/引用/句柄）（因为存在技术上2份A基地）; 因此调用了B1::read() { this->write(); } B1::read() { this->write(); }可能会给出意想不到的行为（虽然不是未定义的）。

基类说明符中的virtual关键字明确指出，其他类基本上从相同基类型继承的类只能获得基类型的一个副本。

请注意，上面的代码将无法编译，编译器错误会解释z1对象的模糊调用。如果你注释掉z1.write(); 和z1.read(); 输出的结果（至少对我来说）如下：

A::A
B1::B1
A::A
C1::C1
Z1::Z1
A::A
B2::B2
C2::C2
Z2::Z2
C2::write
B2::read

注意在构造Z1之前2次调用A ctor（ A::A ），而Z2只有1次调用A构造函数。

我建议阅读关于虚拟继承的以下内容，因为它更深入地了解了其他一些陷阱（比如虚拟继承类需要使用初始化列表来创建基类ctor调用，或者您应该避免在进行这种类型的继承时使用C风格转换）。

它还解释了一些你最初提到的构造函数/析构函数排序，更具体地说明在使用多个虚拟继承时排序是如何完成的。

希望可以帮助清理一些东西。

编译器的输出是正确的。实际上，这是关于虚拟继承的目标。虚拟继承旨在解决多重继承中的“钻石问题”。例如，B继承自A，C继承自A，D继承自B，C。图如下：

    A
   | |
   B C
   | |
    D

因此，D有两个来自B和C的实例A.如果A具有虚函数，则存在问题。

例如：

struct A
{
    virtual void foo(){__builtin_printf("A");}
    virtual void bar(){}
};

struct B : A
{
    virtual void foo(){__builtin_printf("B");}
};

struct C : A
{
    virtual void bar(){}
};

struct D : B, C
{

};

int main()
{
    D d;
    d.foo(); // Error
}

如果我使用我的xlC编译器编译并运行：

xlC -+ a.C

错误消息是这样的：

a.C:25:7: error: member 'foo' found in multiple base classes of different types
    d.foo(); // Error
      ^
a.C:9:18: note: member found by ambiguous name lookup
    virtual void foo(){__builtin_printf("B");}
                 ^
a.C:3:18: note: member found by ambiguous name lookup
    virtual void foo(){__builtin_printf("A");}
                 ^
1 error generated.
Error while processing a.C.

错误消息非常清晰，成员'foo'在不同类型的多个基类中找到。如果我们添加虚拟继承，问题就解决了。因为A的建筑权由D处理，所以有一个A的例子。

回到你的代码，继承关系图如下所示：

A     A
|     |
B1    B2
|     |
C1    C2

没有“钻石问题”，这只是单一遗传。所以，施工顺序也是A-> B2-> C2，输出没有差别。

您将无法看到输出中的任何差异，因为输出在以下任何级别中都是相同的：

Hiearchy 1

class A {};

class  B2 : virtual public A {};

class  C2 : virtual public B2 {};

Hiearchy 2

class A {};

class  B2 : public A {};

class  C2 : virtual public B2 {};

Hiearchy 3

class A {};

class  B2 : virtual public A {};

class  C2 : public B2 {};

Hiearchy 3

class A {};

class  B2 : public A {};

class  C2 : public B2 {};

在所有这些情况下，首先执行A::A() ，然后执行B2::B2() ，然后执行C2::C2() 。

它们之间的区别是什么时候A::A()被调用。它是否从B2::B2()或C2::C2()调用？

我对Hiearchy 1的答案并不是100％清楚。我认为B2::B2()应该从C2::C2调用，因为B2是C的虚拟基类。 A::A()应该从B2:B2()调用，因为A是B2的虚拟基类。但是，我可能在确切的顺序上是错的。

在层次2中 ， A::A()将从B2::B2()调用。由于B2是C2的virtual基类， B2::B2()从C2::C2()被调用。由于A是B2的普通基类，所以A::A()从B2::B2()被调用。

在层次2中 ，将从C2::C2()调用A::A() C2::C2() 。由于A是一个虚拟基类，所以A::A()从C2::C2()被调用。在对A::A()的调用完成后， B2::B2()被调用。

在层次4中 ， A::A()将从B2::B2()调用。我认为这个案子不需要解释。

为了澄清我对Hiearchy 1的疑问，我使用了以下程序：

#include <iostream>

class A
{
   public:
      A(char const *from) { std::cout << "Called from : " << from << std::endl; }

};

class  B2 : virtual public A
{
   public:
      B2() : A("B2::B2()") {}
};

class  C2 : virtual public B2
{
   public:
      C2() : A("C2::C2()") {}
};

int main()
{
   C2 c;
}

我得到了以下输出：

Called from : C2::C2()

这证实了@TC在他的评论中所表明的内容，这与我所期望的不同。 A::A()从C2::C2调用，而不是从B2::B2调用。

链接地址: http://www.djcxy.com/p/26707.html

上一篇: virtual inheritance constructor order

下一篇: How can remove padding or margin in Tabwidget in android?