刷到一篇文章：

作者：

原文：虛擬繼承的邪惡

讨论到这样的一个程序，最终输出什么？？？

代码有简化命名

using namespace std;class A
{
public:A(int a = 0) : v(a) {};int v;
};template <typename T>
class B : public virtual A
{
};class C : public B<C>
{
public:C(int a) : A(a) {};
};class D : public C
{
public:D(int a) : C(a) {};
};int main()
{cout << C(123).v << endl;cout << D(456).v << endl;return 0;
}

答案是：

123
0

是不是反直觉？为什么D(456)变成了0？？？

原文给出的问题答案：

事實上，上面的行為完全符合 C++ 標準的定義。簡單講，C++ 在初始化物件的時候，有下面幾個步驟：1、按 depth-first traversal 對每一個 virtual base class 初始化一次。
2、依序初始化所有的 direct non-virtual base classes。

接下来看看代码到底是怎么生成的：

A(int a = 0) : v(a) {}; 这一行，没有任务问题，很常规的构造函数，赋值

0000000000401232 <A::A(int)>:A(int a = 0) : v(a) {};401232:	55                   	push   %rbp401233:	48 89 e5             	mov    %rsp,%rbp401236:	48 89 7d f8          	mov    %rdi,-0x8(%rbp)40123a:	89 75 f4             	mov    %esi,-0xc(%rbp)40123d:	48 8b 45 f8          	mov    -0x8(%rbp),%rax401241:	8b 55 f4             	mov    -0xc(%rbp),%edx401244:	89 10                	mov    %edx,(%rax)401246:	90                   	nop401247:	5d                   	pop    %rbp401248:	c3                   	ret401249:	90                   	nop

B::B() 默认生成的构造函数，奇怪，为什么没有调用A::A呢？

因为，在这个用例中，B类从来没有被实例化过，B只是一个继承关系中的传宗接代工具人。
如果B没有实例化，那么，A是B的虚基类，A的构造就不需要B来实现，B只会调用B的非虚基类构造函数，此例中，B没有非虚父类

000000000040124a <B<C>::B()>:
class B : public virtual A {};40124a:	55                   	push   %rbp40124b:	48 89 e5             	mov    %rsp,%rbp40124e:	48 89 7d f8          	mov    %rdi,-0x8(%rbp)    # this401252:	48 89 75 f0          	mov    %rsi,-0x10(%rbp)   # 指针401256:	48 8b 45 f0          	mov    -0x10(%rbp),%rax40125a:	48 8b 10             	mov    (%rax),%rdx40125d:	48 8b 45 f8          	mov    -0x8(%rbp),%rax401261:	48 89 10             	mov    %rdx,(%rax)        # 指针里的内容 存到了 this的位置401264:	90                   	nop401265:	5d                   	pop    %rbp401266:	c3                   	ret401267:	90                   	nop

接下来，看到了两个C::C(int)构造函数

为什么会出现两个C::C(int)呢，因为C直接实例化时一个，C被当作传宗接代工具人时另一个。一个需要调用虚基类构造，一个不能。

先看第一个：

这个没有调用虚基类A的构造函数，所以，这个是D使用的基类C的构造函数，当D实例化时，A由D负责实例化，所以C这里不会调用A的构造函数，虽然代码里写了。。。C(int a) : A(a) {};，在这里，A(a)从来没有用到过，不会执行。

%edx,-0x14(%rbp)，dx寄存器是第三个传参，即(int a)，保存到的-0x14(%rbp)地址从没使用过。A(a)没有发生

0000000000401268 <C::C(int)>:C(int a) : A(a) {};401268:	55                   	push   %rbp401269:	48 89 e5             	mov    %rsp,%rbp40126c:	48 83 ec 20          	sub    $0x20,%rsp401270:	48 89 7d f8          	mov    %rdi,-0x8(%rbp)      # this401274:	48 89 75 f0          	mov    %rsi,-0x10(%rbp)     # 还是一个指针401278:	89 55 ec             	mov    %edx,-0x14(%rbp)     # int a 后面没有用到40127b:	48 8b 45 f8          	mov    -0x8(%rbp),%rax40127f:	48 8b 55 f0          	mov    -0x10(%rbp),%rdx401283:	48 83 c2 08          	add    $0x8,%rdx401287:	48 89 d6             	mov    %rdx,%rsi40128a:	48 89 c7             	mov    %rax,%rdi40128d:	e8 b8 ff ff ff       	call   40124a <B<C>::B()>   # B::B(this, 指针 + 8)401292:	48 8b 45 f0          	mov    -0x10(%rbp),%rax401296:	48 8b 10             	mov    (%rax),%rdx401299:	48 8b 45 f8          	mov    -0x8(%rbp),%rax40129d:	48 89 10             	mov    %rdx,(%rax)          # 指针里的内容 存到了 this的位置4012a0:	90                   	nop4012a1:	c9                   	leave4012a2:	c3                   	ret4012a3:	90                   	nop

这一段，是C被实例化时的构造，会调用A::A，对应cout << C(123).v << endl;这一段代码，很符合自觉，int a的值被传下去了，并且首先构造了A，然后编译器又帮我我们自动调用了B的构造。

00000000004012a4 <C::C(int)>:4012a4:	55                   	push   %rbp4012a5:	48 89 e5             	mov    %rsp,%rbp4012a8:	48 83 ec 10          	sub    $0x10,%rsp4012ac:	48 89 7d f8          	mov    %rdi,-0x8(%rbp)      # this4012b0:	89 75 f4             	mov    %esi,-0xc(%rbp)      # int a4012b3:	48 8b 45 f8          	mov    -0x8(%rbp),%rax4012b7:	48 8d 50 08          	lea    0x8(%rax),%rdx4012bb:	8b 45 f4             	mov    -0xc(%rbp),%eax4012be:	89 c6                	mov    %eax,%esi4012c0:	48 89 d7             	mov    %rdx,%rdi4012c3:	e8 6a ff ff ff       	call   401232 <A::A(int)>   # A::A(this + 8, a)4012c8:	48 8b 45 f8          	mov    -0x8(%rbp),%rax4012cc:	ba 88 20 40 00       	mov    $0x402088,%edx4012d1:	48 89 d6             	mov    %rdx,%rsi4012d4:	48 89 c7             	mov    %rax,%rdi4012d7:	e8 6e ff ff ff       	call   40124a <B<C>::B()>   # B::B(this, $0x402088)4012dc:	ba 80 20 40 00       	mov    $0x402080,%edx4012e1:	48 8b 45 f8          	mov    -0x8(%rbp),%rax4012e5:	48 89 10             	mov    %rdx,(%rax)          # *this = $0x4020804012e8:	90                   	nop4012e9:	c9                   	leave4012ea:	c3                   	ret4012eb:	90                   	nop

D类同理，D被实例化，先构造虚基类A

但是D(int a) : C(a) {};，我们自己写了D的构造函数，但没有按照C++规范在虚继承的最后的派生类中构造虚基类，所以，很不幸的是这里编译器帮我们构造了虚基类A，调用了虚基类的默认构造或有默认值的构造函数A::A(int a = 0)，这里是按a=0进行了A的构造，编译器没有向我们发出警告。。。

然后，由于虚基类应该由我们构造，我们没指定，进行了默认构造

接下来是非虚基类的构造，C的构造，由于C不是A-B-C-D这一链条中的最后的派生类，C不会构造A（还记得吗，编译器生成了两个C::C），B也不会构造A（编译器生成的B::B只有一个，非最远派生类的构造函数，不会构造A）

所以D(int a) : C(a) {}; 并没有按照我们预期的工作。。。

00000000004012ec <D::D(int)>:D(int a) : C(a) {};4012ec:	55                   	push   %rbp4012ed:	48 89 e5             	mov    %rsp,%rbp4012f0:	48 83 ec 10          	sub    $0x10,%rsp4012f4:	48 89 7d f8          	mov    %rdi,-0x8(%rbp)      # this4012f8:	89 75 f4             	mov    %esi,-0xc(%rbp)      # int a4012fb:	48 8b 45 f8          	mov    -0x8(%rbp),%rax4012ff:	48 83 c0 08          	add    $0x8,%rax401303:	be 00 00 00 00       	mov    $0x0,%esi401308:	48 89 c7             	mov    %rax,%rdi40130b:	e8 22 ff ff ff       	call   401232 <A::A(int)>   # A::A(this + 8, 0)，编译器帮我们构造了A，但用了默认构造或有默认值的构造函数401310:	48 8b 45 f8          	mov    -0x8(%rbp),%rax401314:	b9 28 20 40 00       	mov    $0x402028,%ecx401319:	8b 55 f4             	mov    -0xc(%rbp),%edx40131c:	48 89 ce             	mov    %rcx,%rsi40131f:	48 89 c7             	mov    %rax,%rdi401322:	e8 41 ff ff ff       	call   401268 <C::C(int)>   # C::C(this, $0x402028, a)，但这里调用的C::C构造不会用到 a401327:	ba 20 20 40 00       	mov    $0x402020,%edx40132c:	48 8b 45 f8          	mov    -0x8(%rbp),%rax401330:	48 89 10             	mov    %rdx,(%rax)          # *this = $0x402020401333:	90                   	nop401334:	c9                   	leave401335:	c3                   	ret

最后回头看main，一切都很平常，正常调用C::C和D::D，只是调用C::C时候，C写了构造A，而调用D::D之后没写构造A，追踪造成第一次输出正常，第二输出了0

int main()
{401176:	55                   	push   %rbp401177:	48 89 e5             	mov    %rsp,%rbp40117a:	48 83 ec 20          	sub    $0x20,%rspcout << C(123).v << endl;40117e:	48 8d 45 e0          	lea    -0x20(%rbp),%rax401182:	be 7b 00 00 00       	mov    $0x7b,%esi401187:	48 89 c7             	mov    %rax,%rdi40118a:	e8 15 01 00 00       	call   4012a4 <C::C(int)>   # C::C(-20(bp), 123)40118f:	8b 45 e8             	mov    -0x18(%rbp),%eax401192:	89 c6                	mov    %eax,%esi401194:	bf 40 40 40 00       	mov    $0x404040,%edi401199:	e8 d2 fe ff ff       	call   401070 <std::basic_ostream<char, std::char_traits<char> >::operator<<(int)@plt>  # <<(cout, -18(rbp)) 此时，c->v 直接获得地址40119e:	be 30 10 40 00       	mov    $0x401030,%esi4011a3:	48 89 c7             	mov    %rax,%rdi4011a6:	e8 a5 fe ff ff       	call   401050 <std::basic_ostream<char, std::char_traits<char> >::operator<<(std::basic_ostream<char, std::char_traits<char> >& (*)(std::basic_ostream<char, std::char_traits<char> >&))@plt>cout << D(456).v << endl;4011ab:	48 8d 45 f0          	lea    -0x10(%rbp),%rax4011af:	be c8 01 00 00       	mov    $0x1c8,%esi4011b4:	48 89 c7             	mov    %rax,%rdi4011b7:	e8 30 01 00 00       	call   4012ec <D::D(int)>   # D::D(-10(bp), 456)4011bc:	8b 45 f8             	mov    -0x8(%rbp),%eax4011bf:	89 c6                	mov    %eax,%esi4011c1:	bf 40 40 40 00       	mov    $0x404040,%edi4011c6:	e8 a5 fe ff ff       	call   401070 <std::basic_ostream<char, std::char_traits<char> >::operator<<(int)@plt>  # <<(cout, -8(rbp)) 此时，d->v 直接获得地址4011cb:	be 30 10 40 00       	mov    $0x401030,%esi4011d0:	48 89 c7             	mov    %rax,%rdi4011d3:	e8 78 fe ff ff       	call   401050 <std::basic_ostream<char, std::char_traits<char> >::operator<<(std::basic_ostream<char, std::char_traits<char> >& (*)(std::basic_ostream<char, std::char_traits<char> >&))@plt>return 0;4011d8:	b8 00 00 00 00       	mov    $0x0,%eax4011dd:	c9                   	leave4011de:	c3                   	ret

原作者这段写的一点没错，不过通过汇编的角度观察，我们知道了编译器是如何实现的：

虚继承的派生类构造函数，编译器为一个构造函数生成了两个实现，分别是这个派生类直接实例化时的构造韩慧，会先构造虚基类，一个是作为其他类的基类时，不会构造虚基类，虚基类由其最后的派生类负责构造。

如果派生类忘记构造虚基类，编译器会帮助我们进行执行基类的默认构造或有默认值的构造，而这，没有警告，悄悄发生。

事實上，上面的行為完全符合 C++ 標準的定義。簡單講，C++ 在初始化物件的時候，有下面幾個步驟：1、按 depth-first traversal 對每一個 virtual base class 初始化一次。
2、依序初始化所有的 direct non-virtual base classes。

最后，补一个作者提到的google c++ 规范

眾所周知，虛擬繼承是為了解決多重繼承產生的 diamond problem 而來的概念。大概是因為虛擬繼承有這些不為人知的眉角，Google C++ Style Guide 才會明定如果要多重繼承，所有的 direct base class 都得是純粹的 interface 而不能帶有成員變數。

c++魔法无比强大。。。