1、单继承与多继承
单继承是一般的单一继承，一个子类只 有一个直接父类时称这个继承关系为单继承。这种关系比较简单是一对一的关系：
多继承是指 一个子类有两个或以上直接父类时称这个继承关系为多继承。这种继承方式使一个子类可以继承多个父类的特性。多继承可以看作是单继承的扩展。派生类具有多个基类，派生类与每个基类之间的关系仍可看作是一个单继承。多继承下派生类的构造函数与单继承下派生类构造函数相似，它必须同时负责该派生类所有基类构造函数的调用。同时，派生类的参数个数必须包含完成所有基类初始化所需的参数个数。在子类的内存中它们是按照声明定义的顺序存放的，下面的截图将清晰看到。
菱形继承也叫钻石继承
但是多继承存在一个问题，要想研究这个问题，我们先从单继承讲起。来看内存空间：
class Base
{
public:
Base() {
cout << "B()" << endl;
}
int b1;
};
class Derive : public Base
{
public:
Derive() {
cout << "D()" << endl;
}
int d1;
};
int main()
{
Test();
getchar();
return ;
}
多继承的内存空间：
class Base
{
public:
Base() {
cout << "B()" << endl;
}
int b1;
};
class C
{
public:
C() {
cout << "C()" << endl;
}
int c;
};
class Derive : public Base, public C
{
public:
Derive() {
cout << "D()" << endl;
}
int d1;
};
菱形继承内存中数据分布：
class A
{
public:
A() {
cout << "A()" << endl;
}
int a;
};
class Base:public A
{
public:
Base() {
cout << "B()" << endl;
}
int b1;
};
class C: public A
{
public:
C() {
cout << "C()" << endl;
}
int c;
};
class Derive : public Base, public C
{
public:
Derive() {
cout << "D()" << endl;
}
int d1;
};
在A类中初始化int a=4则可清楚的看到菱形继承中内存分布
所以子类Derive中有两份A类中的数据成员，这造成了访问二义性和数据冗余的问题
这就是我前面说的多继承存在的问题。可以这样访问
tmp.C::a=;
tmp.Base::a=;
什么是对象模型
有两个概念可以解释C++对象模型：
1、语言中直接支持面向对象程序设计的部分。
2、对于各种支持的底层实现机制。
菱形继承对象模型如下：
2、虚继承
还有另外一个方法解决这个问题，我们要用到一种新的继承方法：虚继承 是面向对象编程中的一种技术，是指一个指定的基类，在继承体系结构中，将其成员数据实例共享给也从这个基类型直接或间接派生的其它类，它可共享的特性，避免了拷贝多份相同的数据，从而解决菱形继承的二义性和数据冗余的问题。看下面这段代码：
class Base
{
public:
Base() {
cout << "B()" << endl;
}
int b1;
};
class Derive : virtual public Base
{
public:
Derive() {
cout << "D()" << endl;
}
int d1;
};
void Test()
{
Derive tmp;
tmp.d1 = ;
tmp.b1 = ;
}
int main()
{
Test();
getchar();
return ;
}
虚拟继承的关键字---virtual
下图为单继承的内存分布：
图中的偏移量地址其实为一个指向基类偏移量表的指针。
虚拟继承是虽然不是多重继承中特有的概念。但虚拟基类是为解决多重继承而出现的。
下图可以看出虚基类和非虚基类在多重继承中的区别
虚继承的提出就是为了解决多重继承时可能会保存两份副本的问题，也就是说用了虚继承就只保留了一份副本，但是这个副本是被多重继承的基类所共享的，该怎么实现这个机制呢？待我慢慢道来
1.类中无其它数据成员时
class B //基类
{
public:
B()
{
cout << "B" << endl;
}
~B()
{
cout << "~B()" << endl;
}
};
class C1 :virtual public B
{
public:
C1()
{
cout << "C1()" << endl;
}
~C1()
{
cout << "~C1()" << endl;
}
};
class C2 :virtual public B
{
public:
C2()
{
cout << "C2()" << endl;
}
~C2()
{
cout << "~C2()" << endl;
}
};
class D :public C1, public C2
{
public:
D()
{
cout << "D()" << endl;
}
~D()
{
cout << "~D()" << endl;
}
}; int main()
{
cout << sizeof(B) << endl;
cout << sizeof(C1) << endl;
cout << sizeof(C2) << endl;
cout << sizeof(D) << endl;
return ;
}
输出结果为：
结果分析：首先，基类中除了构造函数和析构函数没有其他成员了，所以 sizeof(B) = 1;这里再提一个问题有的初学者可能会问为什么为1呢？首先类在内存中的存储是这样的：
如果有一个类Base定义如下例：
class Base
{
public:
void fun();
int b;
};
int Test()
{
Base b1,b2,b3;
}
那么在内存中的对象模型如下图：
成员函数是单独存储的，并且所有为类对象公用。
类的实例化要求每个实例对象在有独立无二的地址空间，而空类也可以实例化。编译器要区分开所有的类对象，就要给对象一个地址，只是一个占位符，表示这个对象存在，并且让编译器给这个对象分配地址。至于占多少位，由编译器决定，这里空类的大小为1，是在VS2015中，其他编译器可能不同。
由于C1与C2都是虚拟继承，故会在C1，C2内存起始处存放一个vbptr，为指向偏移量表的指针。所以C1和C2大小为4，这就是指针的大小了。D的大小就是继承的两个指针的大小了。这里再详细解释一下偏移量表，是什么的偏移量呐？
我们在main函数中生成一个C1类对象c1：
int main()
{
C1 c1;
return ;
}
内存布局如下：
由图可以看出，c1占了四个字节，存了一个指针变量，指针变量的内容就是 c1 的 vbptr 指向的偏移量表的地址。偏移量表有八个字节，分别存的为0和4。 那么0和4代表的都是什么呢？ 虚基类表存放的为两个偏移地址，分别为0和4。其中0表示c1对象地址相对于存放vbptr指针的地址的偏移量。（因为vbptr指针是属于c1对象的，c1对象地址相对于vbptr指针的地址偏移量为0。这里我把它这个表叫做偏移量表，避免与后面多态中的虚表混淆。）
而4表示c1对象中基类对象部分相对于存放vbptr指针的地址的偏移量，可以用 &c1(B)-&vbpt 表示，其中&c1(B)表示对象c1中基类B部分的地址。
c2的内存布局与c1一样，因为C1，C2都是虚继承自B基类，且C1，C2都没有独自的数据成员。
总结：C1，C2是虚继承自基类B，所以编译器会给C1，C2中生成一个指针vbptr指向一个偏移量表，即指针vbptr的值是偏移量表的地址。表中存放对象相对于偏移量表指针的偏移量。表中分两部分，第一部分存储的是对象相对于存放vptr指针的偏移量，可以用&(对象名)->vbptr_(对象名)来表示。对c1对象来说，可以用&c1->vbprt_c1来表示。表的第二部分存储的是对象中基类对象部分相对于存放vbptr指针的地址的偏移量，我们知道在本例中基类对象与指针偏移量就是指针的大小。
下面再来看看D的内存结构：
如图所示，d中存放了两个虚基类指针，每个虚基类表中存储了偏移量。形象的内存布局如下图：
2.类中加数据成员
下面看一下拥有独立数据成员的类的虚继承，可以更清晰的理解内存布局：
#include <iostream>
using namespace std; class B
{
public:
B()
{
cout << "B" << endl;
}
~B()
{
cout << "~B()" << endl;
}
int b;
};
class C1 :virtual public B
{
public:
C1()
{
cout << "C1()" << endl;
}
~C1()
{
cout << "~C1()" << endl;
}
int c1;
};
class C2 :virtual public B
{
public:
C2()
{
cout << "C2()" << endl;
}
~C2()
{
cout << "~C2()" << endl;
}
int c2;
};
class D :public C1, public C2
{
public:
D()
{
cout << "D()" << endl;
}
~D()
{
cout << "~D()" << endl;
}
void fun()
{
b = ;
c1 = ;
c2 = ;
d = ;
}
int d;
}; int main()
{
cout << sizeof(B) << endl;
cout << sizeof(C1) << endl;
cout << sizeof(C2) << endl;
cout << sizeof(D) << endl;
D d;
d.fun();
return ;
}
输出结果为：
B占四个字节没有问题，因为B类中有int b数据成员，所以B类占四个字节。 C1，C2是虚继承自B类的，所以C1，C2的内存布局是相似的，在这里我只分析一下C1。 我在C1类中加一个Fun成员函数，为了更清楚的看到内存布局：
class C1 :virtual public B
{
public:
C1()
{
cout << "C1()" << endl;
}
~C1()
{
cout << "~C1()" << endl;
}
void Fun()
{
b = ;
c1 = ;
}
int c1;
};
int main()
{
C1 c1;
c1.Fun();
return ;
}
在main函数中生成对象c1，C1=int+int+指针=4+4+4=12，再来看一看内存布局：
现在来看看D类的内存布局：
class D :public C1, public C2
{
public:
D()
{
cout << "D()" << endl;
}
~D()
{
cout << "~D()" << endl;
}
void fun()//fun()函数主要帮助我们看D类的内存布局
{
b = ;//基类数据成员
c1 = ;//C1类数据成员
c2 = ;//C2类数据成员
d = ;//D类自己的数据成员
}
int d;
};
内存布局如下：
下面再看看多重虚拟继承
class A
{
public:
A() {
cout << "A()" << endl;
}
int a ;
};
class Base : virtual public A
{
public:
Base() {
cout << "B()" << endl;
}
int b1;
};
class C:virtual public A
{
public:
C() {
cout << "C()" << endl;
}
int c;
};
class Derive : virtual public Base, virtual public C
{
public:
Derive() {
cout << "D()" << endl;
}
int d1;
};
void Test()
{
Derive tmp;
tmp.d1 = ;
tmp.b1 = ;
tmp.c = ;
tmp.a = ;
}
int main()
{
Test();
getchar();
return ;
}
现在我们直接看内存布局：
