虚函数与继承
空类,空类单继承,空类多继承的sizeof
#include <iostream> using namespace std; class Base1 { }; class Base2 { }; class Derived1:public Base1 { }; class Derived2:public Base1, public Base2 { }; int main() { Base1 b1; Base2 b2; Derived1 d1; Derived2 d2; cout<<"sizeof(Base1) = "<<sizeof(Base1)<<" sizeof(b1) = "<<sizeof(b1)<<endl; cout<<"sizeof(Base2) = "<<sizeof(Base2)<<" sizeof(b2) = "<<sizeof(b2)<<endl; cout<<"sizeof(Derived1) = "<<sizeof(Derived1)<<" sizeof(d1) = "<<sizeof(d1)<<endl; cout<<"sizeof(Derived2) = "<<sizeof(Derived2)<<" sizeof(d1) = "<<sizeof(d1)<<endl; return 0; }
结果:
sizeof(Base1) = 1 sizeof(b1) = 1 sizeof(Base2) = 1 sizeof(b2) = 1 sizeof(Derived1) = 1 sizeof(d1) = 1 sizeof(Derived2) = 1 sizeof(d1) = 1
C++标准规定类的大小不为0,空类的大小为1,当类不包含虚函数和非静态数据成员时,其对象大小也为1。
含有虚函数的类以及虚继承类的sizeof
如果在类中声明了虚函数(不管是1个还是多个),那么在实例化对象时,编译器会自动在对象里安插一个指针指向虚函数表(Virtual Table),在32位机器上,一个对象会增加4个字节来存储此指针,它是实现面向对象中多态的关键。而虚函数本身和其他成员函数一样,是不占用对象的空间的。编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置(这是为了保证正确取到虚函数的偏移量)。
#include<iostream> using namespace std; class Base { public: virtual void f() { cout << "Base::f" << endl; } virtual void g() { cout << "Base::g" << endl; } virtual void h() { cout << "Base::h" << endl; } }; int main() { Base base; cout << "sizeof(Base) = " << sizeof(Base) << " sizeof(base) = " << sizeof(base) << endl; }
输出
sizeof(Base) = 4 sizeof(base) = 4其base中成员的存放如下:(即使有其他成员,vfptr也还是放在最前面)
虚函数表的最后多加了一个结点,这是虚函数表的结束结点,就像字符串的结束符"\0"一样,其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下,这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下,这个值是如果1,表示还有下一个虚函数表,如果值是0,表示是最后一个虚函数表。因为对象bese中多了一个指向虚函数表的指针,而指针的sizeof是4,因此含有虚函数的类或实例最后的sizeof是实际的数据成员的sizeof加4。可以验证一下:
typedef void(*Fun)(void); int main() { Base base; Fun pFun = NULL; int** pVtab = (int**)&base; pFun = (Fun)pVtab[0][0]; pFun(); pFun = (Fun)pVtab[0][1]; pFun(); pFun = (Fun)pVtab[0][2]; pFun(); cout << pVtab[0][3] << endl; cout << "sizeof(Base) = " << sizeof(Base) << " sizeof(base) = " << sizeof(base) << endl; }
输出
Base::f Base::g Base::h 0 sizeof(Base) = 4 sizeof(base) = 4
基类含有虚函数的继承
在派生类中不对基类的虚函数进行覆盖,同时派生类中还拥有自己的虚函数,比如有如下的派生类:
class Derived: public Base { public: virtual void f1() { cout << "Derived::f1" << endl; } virtual void g1() { cout << "Derived::g1" << endl; } virtual void h1() { cout << "Derived::h1" << endl; } };当定义一个Derived的对象d后,其成员的存放如下:
可以发现:
1)虚函数按照其声明顺序放于表中。
2)父类的虚函数在子类的虚函数前面。
此时基类和派生类的sizeof都是数据成员的sizeof加4。
在派生类中对基类的虚函数进行覆盖,假设有如下的派生类:
class Derived: public Base { public: virtual void f() { cout << "Derived::f" << endl; } virtual void g1() { cout << "Derived::g1" << endl; } virtual void h1() { cout << "Derived::h1" << endl; } };基类和派生类之间的关系:其中基类的虚函数f在派生类中被覆盖了。当我们定义一个派生类对象d后,其d的成员存放为:
可以发现:
1)覆盖的f()函数被放到了虚表中原来父类虚函数的位置。
2)没有被覆盖的函数依旧。
这样,我们就可以看到对于下面这样的程序,
Base *b = new Derive();
b->f();
由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代,于是在实际调用发生时,是Derive::f()被调用了。这就实现了多态。
int main() { Base base; Derived d; Fun pFun = NULL; int** pVtab = (int**)&d; pFun = (Fun)pVtab[0][0]; pFun(); pFun = (Fun)pVtab[0][1]; pFun(); pFun = (Fun)pVtab[0][2]; pFun(); pFun = (Fun)pVtab[0][3]; pFun(); pFun = (Fun)pVtab[0][4]; pFun(); cout << pVtab[0][5] << endl; }
输出
Derived::f1 Base::g Base::h Derived::g1 Derived::h1 0多继承:无虚函数覆盖
假设基类和派生类之间有如下关系:
对于子类实例中的虚函数表,是下面这个样子:
可以看到
1) 每个父类都有自己的虚表。
2) 子类的成员函数被放到了第一个父类的表中。(所谓的第一个父类是按照声明顺序来判断的)
由于每个基类都需要一个指针来指向其虚函数表,因此d的sizeof等于d的数据成员加3*4=12。
多重继承,含虚函数覆盖
假设,基类和派生类又如下关系:派生类中覆盖了基类的虚函数f
下面是对于子类实例中的虚函数表的图:
我们可以看见,三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样,我们就可以任一静态类型的父类来指向子类,并调用子类的f()了。
虚函数及虚继承
#include <iostream> using namespace std; class Base { public: virtual void f(); virtual void g(); virtual void h(); }; class Derived1: public Base { public: virtual void f1(); virtual void g1(); virtual void h1(); }; class Derived2:public Base { public: virtual void f(); virtual void g1(); virtual void h1(); }; class Derived3:virtual public Base { public: virtual void f1(); virtual void g1(); virtual void h1(); }; class Derived4:virtual public Base { public: virtual void f(); virtual void g1(); virtual void h1(); }; class Derived5:virtual public Base { public: virtual void f(); virtual void g(); virtual void h(); }; class Derived6:virtual public Base { }; int main() { cout<<sizeof(Base)<<endl; //4 cout<<sizeof(Derived1)<<endl; //4 cout<<sizeof(Derived2)<<endl; //4 cout<<sizeof(Derived3)<<endl; //12 cout<<sizeof(Derived4)<<endl; //12 cout<<sizeof(Derived5)<<endl; //8 cout<<sizeof(Derived6)<<endl; //8 return 0; }
当涉及到虚继承时会涉及到虚基类指针,如对Derived3或Derived4定义一个对象d,其里面会出现三个跟虚函数以及虚继承的指针,因为是虚继承,因此引入一个指针指向虚继承的基类,第二由于在基类中有虚函数,因此需要指针指向其虚函数表,由于派生类自己本身也有自己的虚函数,因为采取的是虚继承,因此它自己的虚函数不会放到基类的虚函数表的后面,而是另外分配一个只存放自己的虚函数的虚函数表,于是又引入一个指针,
上面的这种情况是在VC编译器的情况,但在GCC都是将虚表指针在整个继承关系中共享的,不共享的是指向虚基类的指针。
class A { int a; virtual ~A(){} }; class B:virtual public A{ virtual void myfunB(){} }; class C:virtual public A{ virtual void myfunC(){} }; class D:public B,public C{ virtual void myfunD(){} };
在VS情况下:
sizeof(A)=8,sizeof(B)=16,sizeof(C)=16,sizeof(D)=24.
D大小就等于A+B的虚表指针+C的虚表指针+B中的指向虚基类的指针+C中的指向虚基类的指针。
在GCC情况下
sizeof(A)=8,sizeof(B)=12,sizeof(C)=12,sizeof(D)=16.D大小就等于A+B中的指向虚基类的指针+C中的指向虚基类的指针。
多次虚继承
class A { public: int a; }; class B : virtual public A { public: int b; }; class C : virtual public B { };
结果
sizeof(A) = 4 sizeof(a) = 4 sizeof(B) = 12 sizeof(b) = 12 sizeof(C) = 16 sizeof(c) = 16不知道是否C与B之间又建立了一个虚基类指针导致C的大小比B大4,虚基类表是否只有一张有待确定。
class A { public: int a; }; class B : virtual public A { }; class C : virtual public A { }; class D : public B, public C{ };C的大小为12,此时C有两张虚基类表和一个A实例