1. 在只有继承没有多态的情况下，子类是的内容就是父类加上子类特有的数据成员，例如，对于如下两个类，Point2d和Point3d，后者公有继承自前者，此时的数据布局如下所示：
在某些情况下，把一个类分解成多层，可能会导致类所占用空间的膨胀，例如，如下类，算上对齐操作大小为8 （4 + 1 + 1+1 +(1对齐)）：
而如果相同的数据（val，c1，c2，c3），被分散的放入继承体系之中，现在一个包含所有这些数据的类Concrete3的大小就膨胀到了16，这是因为上面的无继承的类设计中，只有一个字节被用来对齐，而此种继承体系之下，有9个字节被用来对齐：
这时的类的布局如下：
为什么不把Concrete2和Concrete3的数据填补到Concrete1用于对齐的空间中呢？原因时，在此种情况下，当发生Concrete1的复制操作时，会破坏Concrete2的内容：
2. 加入多态时的情况，例如，街上上述的例子，对于Point2d，现在加入几个虚函数，用以支持多态特性：
此时会带来额外的空间以及存取时间上的额外负担：
a. 虚函数表会被产生出来（virtual table）。
b. 每一个类对象中会加入一个指向上述虚表的指针（vptr）。
c. 加强构造函数，使之可以为vptr设定初值。
d. 加强析构函数，使之可以清除指向虚函数表的vptr。
此时的类的内存布局会增加一个指向虚表的指针（该指针可能放在头部也可能放在尾部）：
3. 多种继承的情况，在单继承中，可以看到，基类和子类的对象都是从相同的地址开始的，差异只是子类比较大，例如以下操作，
- P3d p3d;
- P2d* p = &p3d;
以基类指针指向子类指针并不需要修改地址，多重继承则不一样，因为第二个乃至后面的基类起始地址与对应基类的地址并不一样，例如对于如下继承体系以及对应的内存布局：
从上图看以看出，最左端基类（P2d和P3d）的起始地址和子类V3d是一样的，而之后的基类Vertex则和子类不一致，因此，对于如下对象和指针：
- Vertex3d v3d;
- Vertex* pv;
- Point2d* p2d;
- Point3d* p3d;
如下的赋值操作：pv = v3d; 需要内部转化为：pv = (Vertex*)(((char*)&v3d) + sizeof(Point3d));即需要偏移才可以指向子类中对应的该基类的部分，而对于如下赋值：p2d = &v3d;p3d = &v3d; 则不需要任何调整。
如果要存取第二个或者后继基类中的一个数据成员，并不需要额外负担，因为数据成员的位置在编译时期就固定了，因此存取只是一个简答的位移（offset）运算，并不需要额外成本。
4. 虚拟继承的情况，考虑如下继承体系，Vertex和Point3d虚拟继承自Point2d，Vertex3d共有继承(非虚继承)自Vertex和Point3d
a. 此时必须有在子类对象中安插指针指向虚基类，一种可能的布局如下，子类需要维护指向虚基类地址的指针，此种策略下，对于Point3d运算符：
- void Point3d::operator+=(const Point3d& rhs)
- {
- _x += rhs._x;
- _y += rhs._y;
- _z += rhs._z;
- };
- pPoint2d->_x += rhs.pPoint2d->_x;
- pPoint2d->_y += rhs.pPoint2d->_y;
- _z += rhs._z;
- Point2d* p2d = pv3d; //Vertex3d* pv3d
会被转化为（必须判断pv3d是否为空，否则可能导致不正确的赋值）：
- Point2d* p2d = pv3d ? pv3d->pPoint2d : 0;
b. 另一种策略是将虚基类的偏移量（而不是地址）存入虚表中（以下例子中，虚表中的正值索引会索引到虚函数地址，负值索引会索引到虚基类偏移量），也就是与虚函数放到一个表中，针对上例，此种策略下可能的布局如下，此种策略下，上述+=运算符会被转化为：
- (this + __vptr__Point3d[-1])->_x += (rhs + rhs.__vptr__Point3d[-1])->_x;
- (this + __vptr__Point3d[-1])->_y += (rhs + rhs.__vptr__Point3d[-1])->_y;
- _z += rhs._z;
- Point2d* p2d = pv3d;
会转化为：
- Point2d* p2d = pv3d ？ pv3d + pv3d->__vptr__Point3d[-1] ： 0；
由于虚拟继承的存在带来了额外的负担以及高度的复杂性，所以，一般而言，“虚基类的最有效的运用形式就是：一个抽象的虚基类，没有任何数据成员。”
类B和类C通过虚继承的方式派生自类A，这两个对象的内存布局中，编译器在对象中添加了一个vbptr(virtual base pointer)指针，vbptr指向了一张表，这张表保存了当前的虚指针相对于虚基类的首地址的偏移量。类D派生与类B和类C，继承了两个基类的vbptr指针，并调整了vbptr与虚基类的首地址的偏移量,使得这种菱形问题在继承时只继承一份数据，并且解决了二义性的问题。
当使用虚继承时，虚基类是被共享的，也就是在继承体系中无论被继承多少次，对象内存模型中都只会出现一个虚基类的子对象。
1. 数据成员指针是指指向类数据成员的指针，其内容为对应数据成员在类对象中的偏移量，类型为A::*，例如，如下类：
- class Point3d {
- public:
- virtual ~Point3d();
- protected:
- static Point3d origin;
- float x, y, z;
- };
- float Point3d::*p1 = 0;
- float Point3d::*p2 = &Point3d::x;
指向数据成员的指针的使用方法：
- float Point3d::*p2 = &Point3d::x;
- Point3d point;
- point.*p2 = 1//等价于point.x = 1
- Point3d* p3d = &point;
- p3d->*p2 = 2;//等价于p3d->x = 2
2. 多重继承的情况下，将第二个（或者后继）基类指针与一个和子类对象绑定的数据成员结合起来时，情况会变得复杂，例如：
此种情况下，必须要考虑Base1存在导致的Base2的偏移，注意判零：func1(bmp ? bmp + sizeof(Base1) : 0, pd );
本文从5段代码实例出发。通过类中类的普通继承，类的虚继承，类的多重继承，多个虚函数类的普通继承、虚继承与多重继承，几个交叉概念，具体的阐释了继承、虚函数与虚继承的基本概念。深入剖析了继承于虚继承的差别于联系。
【Exp.001-虚继承】
#include <stdio.h>
class A {
public:
int a;
};//sizeof(A)=4
class B : virtual public A {
public:
int b;
};//sizeof(B)=4(A副本)+4(虚表指针)+4(自己变量)=12
class C : virtual public B {
};//sizeof(c)= 12(B副本)+4(虚表指针) = 16，假设这里改为直接继承，那么sizeof(c)=12
int main() {
printf("%d\n", sizeof(C));
return 0;
}
解析：这里须要理解虚继承基类对派生类的空间大小的影响，理解虚指针在虚继承中为子类带来了哪些空间的改变。
【Exp.002-多重继承】
#include <stdio.h>
class A {
public:
int a;
};//sizeof(A) = 4
class B : virtual public A {
};// sizeof(B) =4+4=8
class C : virtual public A {
};//sizeof(C) =4+4=8
class D : public B, public C{
};
//sizeof(D)=8+8-4=12 这里须要注意要减去4，由于B和C同一时候继承A，仅仅须要保存一个A的副本就好了，sizeof(D)=4(A的副本)+4(B的虚表)+4(C的虚表)=12
int main() {
printf("%d\n", sizeof(D));
return 0;
}
解析：这里须要关注 class D 的数据空间大小，理解多重虚继承对派生类虚指针以及派生类空间的影响。
【Exp.003-普通继承（含有：空类、虚函数）】
class A
{
};
class B
{
char ch;
virtual void func0() { }
};
class C
{
char ch1;
char ch2;
virtual void func() { }
virtual void func1() { }
};
class D: public A, public C
{
int d;
virtual void func() { }
virtual void func1() { }
};
class E: public B, public C
{
int e;
virtual void func0() { }
virtual void func1() { }
};
int main(void)
{
cout<<"A="<<sizeof(A)<<endl;//result=1 空类所占空间的大小为 1
cout<<"B="<<sizeof(B)<<endl;//result=8 1+4 对齐 8
cout<<"C="<<sizeof(C)<<endl;//result=8 1+1+4 对齐 8
cout<<"D="<<sizeof(D)<<endl;//result=12 C的副本+D本身=8+4=12
cout<<"E="<<sizeof(E)<<endl;//result=20 B的副本+C的副本+E本身=8+8+4=20
return 0;
}
这里须要区分一下：
①没有继承的时候，存在虚函数则须要加上虚指针，假设有多个也仅仅须要加上一个，由于仅仅有一个虚指针；
②对于普通继承，类D和类E中自己的虚函数，大小为0，由于，它没有虚表。
③对于虚继承中。派生类中存在一个或多个虚函数的时候，它本身就有一个虚表，指向自己的虚表，所以要加4。
【Exp.004-虚继承（多重继承和虚函数）】
class CommonBase
{
int co;
};// size = 4
class Base1: virtual public CommonBase
{
public:
virtual void print1() { }
virtual void print2() { }
private:
int b1;
};//4副本+4虚指针+4自身+4(虚继承+虚函数构成指针多一个)=16
class Base2: virtual public CommonBase
{
public:
virtual void dump1() { }
virtual void dump2() { }
private:
int b2;
};//同理16
class Derived: public Base1, public Base2
{
public:
void print2() { }
void dump2() { }
private:
int d;
};//16+16-4+4=32
解析：假设不是虚继承的类。即便有虚函数也不会因此添加存储空间，假设是虚继承的类。没有虚函数就加入一个虚指针空间，有虚函数不论多少个，就加入两个虚指针空间。
【Exp.005-虚继承与虚函数】
class A
{
public:
virtual void aa() { }
virtual void aa2() { }
private:
char ch[3];
}; // 1+4 = 补齐 = 8
class B: virtual public A
{
public:
virtual void bb() { }
virtual void bb2() { }
}; // 8（副本）+4(虚继承)+4（虚指针） = 16
int main(void)
{
cout<<"A's size is "<<sizeof(A)<<endl;// 4+4=8
cout<<"B's size is "<<sizeof(B)<<endl;// A的副本+4+4=16
return 0;
}
解析：假设不是虚继承的类。即便有虚函数也不会因此添加存储空间。假设是虚继承的类。没有虚函数就加入一个虚指针空间，有虚函数不论多少个，就加入两个虚指针空间。
【小结】
重要的事情讲三遍！！
。
假设不是虚继承的类，即便有虚函数也不会因此添加存储空间。假设是虚继承的类。没有虚函数就加入一个虚指针空间，有虚函数不论多少个。就加入两个虚指针空间。。！