原始出处：网络
由于篇幅限制，本篇为《C++从零开始（十一）》的中篇，说明多重继承、虚继承和虚函数的实现方式。
多重继承
这里有个有趣的问题，如下：
struct A { long a, b, c; char d; }; struct B : public A { long e, f; };
上面的B::e和B::f映射的偏移是多少？不同的编译器有不同的映射结果，对于派生的实现，C++并没有强行规定。大多数编译器都是让B::e映射的偏移值为16（即A的长度，关于自定义类型的长度可参考《C++从零开始（九）》），B::f映射20。这相当于先把空间留出来排列父类的成员变量，再排列自己的成员变量。但是存在这样的语义——西红柿即是蔬菜又是水果，鲸鱼即是海洋生物又是脯乳动物。即一个实例既是这种类型又是那种类型，对于此，C++提供了多重派生或称多重继承，用“,”间隔各父类，如下：
struct A { long A_a, A_b, c; void ABC(); }; struct B { long c, B_b, B_a; void ABC(); };
struct AB : public A, public B { long ab, c; void ABCD(); };
void A::ABC() { A_a = A_b = 10; c = 20; }
void B::ABC() { B_a = B_b = 20; c = 10; }
void AB::ABCD() { A_a = B_a = 1; A_b = B_b = 2; c = A::c = B::c = 3; }
void main() { AB ab; ab.A_a = 3; ab.B_b = 4; ab.ABC(); }
上面的结构AB从结构A和结构B派生而来，即我们可以说ab既是A的实例也是B的实例，并且还是AB的实例。那么在派生AB时，将生成几个映射元素？照前篇的说法，除了AB的类型定义符“{}”中定义的AB::ab和AB::c以外（类型均为long AB::），还要生成继承来的映射元素，各映射元素名字的修饰换成AB::，类型不变，映射的值也不变。因此对于两个父类，则生成8个映射元素（每个类都有4个映射元素），比如其中一个的名字为AB::A_b，类型为long A::，映射的值为4；也有一个名字为AB::B_b，类型为long B::，映射的值依旧为4。注意A::ABC和B::ABC的名字一样，因此其中两个映射元素的名字都为AB::ABC，但类型则一个为void( A:: )()一个为void( B:: )()，映射的地址分别为A::ABC和B::ABC。同样，就有三个映射元素的名字都为AB::c，类型则分别为long A::、long B::和long AB::，映射的偏移值依次为8、0和28。照前面说的先排列父类的成员变量再排列子类的成员变量，因此类型为long AB::的AB::c映射的值为两个父类的长度之和再加上AB::ab所带来的偏移。
注意问题，上面继承生成的8个映射元素中有两对同名，但不存在任何问题，因为它们的类型不同，而最后编译器将根据它们各自的类型而修改它们的名字以形成符号，这样连接时将不会发生重定义问题，但带来其他问题。ab.ABC();一定是ab.AB::ABC();的简写，因为ab是AB类型的，但现在由于有两个AB::ABC，因此上面直接书写ab.ABC将报错，因为无法知道是要哪个AB::ABC，这时怎么办？
回想本文上篇提到的公共、保护、私有继承，其中说过，公共就表示外界可以将子类的实例当作父类的实例来看待。即所有需要用到父类实例的地方，如果是子类实例，且它们之间是公共继承的关系，则编译器将会进行隐式类型转换将子类实例转换成父类实例。因此上面的ab.A_a = 3;实际是ab.AB::A_a = 3;，而AB::A_a的类型是long A::，而成员操作符要求两边所属的类型相同，左边类型为AB，且AB为A的子类，因此编译器将自动进行隐式类型转换，将AB的实例变成A的实例，然后再计算成员操作符。
注意前面说AB::A_b和AB::B_b的偏移值都为4，则ab.A_b = 3;岂不是等效于ab.B_b = 3;？即使按照上面的说法，由于AB::A_b和AB::B_b的类型分别是long A::和long B::，也最多只是前者转换成A的实例后者转换成B的实例，AB::A_b和AB::B_b映射的偏移依旧没变啊。因此变的是成员操作符左边的数字。对于结构AB，假设先排列父类A的成员变量再排列父类B的成员变量，则AB::B_b映射的偏移就应该为16（结构A的长度加上B::c引入的偏移），但它实际映射为4，因此就将成员操作符左侧的地址类型的数字加上12（结构A的长度）。而对于AB::A_b，由于结构A的成员变量先被排列，故只偏移0。假设上面ab对应的地址为3000，对于ab.B_b = 4;，AB类型的地址类型的数字3000在“.”的左侧，转成B类型的地址类型的数字3012（因为偏移12），然后再将“.”右侧的偏移类型的数字4加上3012，最后返回类型为long的地址类型的数字3016，再继续计算“=”。同样也可知道ab.A_a = 3;中的成员操作符最后返回long类型的地址类型的数字3000，而ab.A_b将返回3004，ab.ab将返回3024。
同样，这样也将进行隐式类型转换long AB::*p = &AB::B_b;。注意AB::B_b的类型为long B::，则将进行隐式类型转换。如何转换？原来AB::B_b映射的偏移为4，则现在将变成12+4=16，这样才能正确执行ab.*p = 10;。
这时再回过来想刚才提的问题，AB::ABC无法区别，怎么办？注意还有映射元素A::ABC和B::ABC（两个AB::ABC就是由于它们两个而导致的），因此可以书写ab.A::ABC();来表示调用的是映射到A::ABC的函数。这里的A::ABC的类型是void( A:: )()，而ab是AB，因此将隐式类型转换，则上面没有任何语法问题（虽然说A::ABC不是结构AB的成员，但它是AB的父类的成员，C++允许这种情况，也就是说A::ABC的名字也作为类型匹配的一部分而被使用。如假设结构C也从A派生，则有C::a，但就不能书写ab.C::a，因为从C::a的名字可以知道它并不属于结构AB）。同样ab.B::ABC();将调用B::ABC。注意上面结构A、B和AB都有一个成员变量名字为c且类型为long，那么ab.c = 10;是否会如前面ab.ABC();一样报错？不会，因为有三个AB::c，其中有一个类型和ab的类型匹配，其映射的偏移为28，因此ab.c将会返回3028。而如果期望运用其它两个AB::c的映射，则如上通过书写ab.A::c和ab.B::c来偏移ab的地址以实现。
注意由于上面的说法，也就可以这样：void( AB::*pABC )() = B::ABC; ( ab.*pABC )();。这里的B::ABC的类型为void( B:: )()，和pABC不匹配，但正好B是AB的父类，因此将进行隐式类型转换。如何转换？因为B::ABC映射的是地址，而隐式类型转换要保证在调用B::ABC之前，先将this的类型变成B*，因此要将其加12以从AB*转变成B*。由于需要加这个12，但B::ABC又不是映射的偏移值，因此pABC实际将映射两个数字，一个是B::ABC对应的地址，一个是偏移值12，结果pABC这个指针的长度就不再如之前所说的为4个字节，而变成了8个字节（多出来的4个字节用于记录偏移值）。
还应注意前面在AB::ABCD中直接书写的A_b、c、A::c等，它们实际都应该在前面加上this->，即A_b = B_b = 2;实际为this->A_b = this->B_b = 2;，则同样如上，this被偏移了两次以获得正确的地址。注意上面提到的隐式类型转换之所以会进行，是因为继承时的权限满足要求，否则将失败。即如果上面AB保护继承A而私有继承B，则只有在AB的成员函数中可以如上进行转换，在AB的子类的成员函数中将只能使用A的成员而不能使用B的成员，因为权限受到限制。如下将失败。
struct AB : protected A, private B {…};
struct C : public AB { void ABCD(); };
void C::ABCD() { A_b = 10; B_b = 2; c = A::c = B::c = 24; }
这里在C::ABCD中的B_b = 2;和B::c = 24;将报错，因为这里是AB的子类，而AB私有继承自B，其子类无权将它看作B。但只是不会进行隐式类型转换罢了，依旧可以通过显示类型转换来实现。而main函数中的ab.A_a = 3; ab.B_b = 4; ab.A::ABC();都将报错，因为这是在外界发起的调用，没有权限，不会自动进行隐式类型转换。
注意这里C::ABCD和AB::ABCD同名，按照上面所说，子类的成员变量都可以和父类的成员变量同名（上面AB::c和A::c及B::c同名），成员函数就更没有问题。只用和前面一样，按照上面所说进行类型匹配检验即可。应注意由于是函数，则可以参数变化而函数名依旧相同，这就成了重载函数。
虚继承
前面已经说了，当生成了AB的实例，它的长度实际应该为A的长度加B的长度再加上AB自己定义的成员所占有的长度。即AB的实例之所以又是A的实例又是B的实例，是因为一个AB的实例，它既记录了一个A的实例又记录了一个B的实例。则有这么一种情况——蔬菜和水果都是植物，海洋生物和脯乳动物都是动物。即继承的两个父类又都从同一个类派生而来。假设如下：
struct A { long a; };
struct B : public A { long b; }; struct C : public A { long c; };
struct D : public A, public C { long d; };
void main() { D d; d.a = 10; }
上面的B的实例就包含了一个A的实例，而C的实例也包含了一个A的实例。那么D的实例就包含了一个B的实例和一个C的实例，则D就包含了两个A的实例。即D定义时，将两个父类的映射元素继承，生成两个映射元素，名字都为D::a，类型都为long A::，映射的偏移值也正好都为0。结果main函数中的d.a = 10;将报错，无法确认使用哪个a。这不是很奇怪吗？两个映射元素的名字、类型和映射的数字都一样！编译器为什么就不知道将它们定成一个，因为它们实际在D的实例中表示的偏移是不同的，一个是0一个是8。同样，为了消除上面的问题，就书写d.B::a = 1; d.C::a = 2;以表示不同实例中的成员a。可是B::a和C::a的类型不都是为long A::吗？但上面说过，成员变量或成员函数它们自身的名字也将在类型匹配中起作用，因此对于d.B::a，因为左侧的类型是D，则看右侧，其名字表示为B，正好是D的父类，先隐式类型转换，然后再看类型，是A，再次进行隐式类型转换，然后返回数字。假设上面d对应的地址为3000，则d.C::a先将d这个实例转换成C的实例，因此将3000偏移8个字节而返回long类型的地址类型的数字3008。然后再转换成A的实例，偏移0，最后返回3008。
上面说明了一个问题，即希望从A继承来的成员a只有一个实例，而不是像上面那样有两个实例。假设动物都有个饥饿度的成员变量，很明显地鲸鱼应
补充：软件开发 , C++ ,
