c++中虚函数继承，虚表剖析

虚表概念：

对于有虚函数类，编译器都会维护一张虚表，对象的前四个字节就是指向虚表的指针。虚表中存放的是虚函数的地址。虚函数按照其声明顺序存放在虚表中。在派生类中，前面是继承基类的虚函数，若派生类重写了基类中的虚函数则替换为重写后的，派生类自己的虚函数追加在其后。如果派生类继承了两个基类，则派生类自己的虚函数追加到第一个继承的基类的虚表的后面。

单继承（没有重写基类的虚函数）

class Base

{

public:

virtual void FunTest1()

{

cout << "Base::FunTest1" << endl;

}

virtual void FunTest2()

{

cout << "Base::FunTest2" << endl;

}

int _data1;

};

class Drived :public Base

{

public:

virtual void FunTest3()

{

cout << "Drived::FunTest3" << endl;

}

virtual void FunTest4()

{

cout << "Drived::FunTest4" << endl;

}

int _data2;

};

typedef void(*VFP)();

void Printvtp()//打印虚表

{

Drived d;

Base &b = d;

VFP*fun = (VFP*)*(int*)&b;

while (*fun)

{

(*fun)();

++fun;

}

}

int main()

{

Base b;

Drived d;

cout << sizeof(d) << endl;//12（本身的虚表指针地址，data1，，data2共12个字节）

cout << sizeof(b) << endl;//8（本身的虚表指针地址，data1，共八个字节）

Printvtp();

system("pause");

return 0;

}



在派生类中，前面是基类的虚函数，后面是派生类的虚函数

单继承（重写基类的虚函数）

class Base

{

public:

virtual void FunTest1()

{

cout << "Base::FunTest1" << endl;

}

virtual void FunTest2()

{

cout << "Base::FunTest2" << endl;

}

int _data1;

};

class Drived :public Base

{

public:

virtual void FunTest1()

{

cout << "Drived::FunTest1" << endl;

}

virtual void FunTest3()

{

cout << "Drived::FunTest3" << endl;

}

int _data2;

};

测试结果：


由于只重写了基类的FunTest1，所以虚表中打印了派生类重写的FunTest1与基类的FunTest2，再加上派生类本身的虚函数。

派生类虚表的形成： a.先拷贝基类的虚表

b.如果派生类重写了基类的虚函数，则修改同位置的基类虚函数

c.跟上派生类新定义的虚函数

调用虚表：通过基类的引用或指针调用虚函数时，调用基类还是派生类的虚函数，

要根据运行时引用或指针的实际指向的类型确定。

单继承的派生类的大小：虚表+ 基类的数据成员 + 派生类的成员
多继承（无重写）
class Base1

{

public:

Base1()

:_data1(1)

{}

virtual void FunTest1()

{

cout << "Base1::FunTest1" << endl;

}

virtual void FunTest2()

{

cout << "Base1::FunTest2" << endl;

}

int _data1;

};

class Base2

{

public:

Base2()

:_data2(2)

{}

virtual void FunTest3()

{

cout << "Base2::FunTest3" << endl;

}

virtual void FunTest4()

{

cout << "Base2::FunTest4" << endl;

}

int _data2;

};

class Drived:public Base1,public Base2

{

public:

Derived()

:_data3(3)

{}

virtual void FunTest5()

{

cout << "Drived::FunTest5" << endl;

}

virtual void FunTest6()

{

cout << "Drived::FunTest6" << endl;

}

int _data3;

};

typedef void(*VFP)();

void Printvtp()//打印虚表

{

Drived d;

cout << "derived虚表" << endl;

VFP*fun = (VFP*)*(int*)&d;

while (*fun)

{

(*fun)();

++fun;

}

Base1 b1;

fun = (VFP*)*(int*)&b1;

cout << endl;

cout << "base1虚表" << endl;

while (*fun)

{

(*fun)();

++fun;

}

Base2 b2;

fun = (VFP*)*(int*)&b2;

cout << endl;

cout << "base2虚表" << endl;

while (*fun)

{

(*fun)();

++fun;

}

}

int main()

{

Base1 b1;

Base2 b2;

Drived d;

cout << sizeof(d) << endl;//20

cout << sizeof(b1) << endl;//8

cout << sizeof(b2) << endl;//8

Printvtp();

system("pause");

return 0;

}

测试结果：


如果子类有新定义的虚函数，则放在继承顺序第一的基类虚表的后面（可看上图测试结果）

菱形继承（有重写）

class base

{

public:

base()

:_data1(1)

{}

virtual void funtest1()

{

cout << "base::funtest1" << endl;

}

int _data1;

};

class C1 :public base

{

public:

C1()

:_data2(2)

{}

virtual void funtest1()

{

cout << "C1::funtest1" << endl;

}

virtual void funtest2()

{

cout << "C1::funtest2" << endl;

}

int _data2;

};

class C2 :public base

{

public:

C2()

:_data3(3)

{}

virtual void funtest1()

{

cout << "C1::funtest1" << endl;

}

virtual void funtest3()

{

cout << "C2::funtest3" << endl;

}

int _data3;

};

class Derived :public C1, public C2

{

public:

Derived()

:_data4(4)

{}

virtual void funtest1()

{

cout << "Derived::funtest1()" << endl;

}

virtual void funtest2()

{

cout << "Derived::funtest2()" << endl;

}

virtual void funtest3()

{

cout << "Derived::funtest3()" << endl;

}

virtual void funtest4()

{

cout << "Derived::funtest4()" << endl;

}

int _data4;

};

typedef void(*VFP)();

void Printvtp()//打印虚表

{

Derived d;

C1&c1 = d;

VFP*fun = (VFP*)*(int*)&c1;

cout << "c1虚表"<< endl;

while (*fun)

{

(*fun)();

++fun;

}

C2&c2 = d;

fun = (VFP*)*(int*)&c2;

cout << endl;

cout << "c2虚表" << endl;

while (*fun)

{

(*fun)();

++fun;

}

}

int main()

{

Derived d;

cout << sizeof(d) << endl;

Printvtp();

system("pause");

return 0;

}

测试结果：




说明： 如果派生类Derived有新的虚函数，则添加到第一继承顺序的基类c1的虚表后面

该菱形继承存在二义性，c1和c2中都继承了base的成员变量

菱形继承的大小：28 c1(（虚表指针+base成员+c1成员 ）==（12）) + c2（12） + 派生类D的成员（4）