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）