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;
}
解析:假设不是虚继承的类。即便有虚函数也不会因此添加存储空间。假设是虚继承的类。没有虚函数就加入一个虚指针空间,有虚函数不论多少个,就加入两个虚指针空间。
【小结】
重要的事情讲三遍!!
。
假设不是虚继承的类,即便有虚函数也不会因此添加存储空间。假设是虚继承的类。没有虚函数就加入一个虚指针空间,有虚函数不论多少个。就加入两个虚指针空间。。!