C++中虚函数工作原理详解

最新推荐文章于 2025-03-01 21:54:32 发布

土戈

最新推荐文章于 2025-03-01 21:54:32 发布

阅读量384

点赞数

分类专栏： C++面试

C++面试专栏收录该内容

4 篇文章

订阅专栏

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。
所谓泛型技术，比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。
虚函数表（Virtual Table）来实现的。即一个类的虚函数的地址表。

注意：以下代码在64位系统通过，32位的把long改为int

#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; }
};

typedef void(*Fun)(void);

int main()
{
    Base b;
    Fun pFun = NULL;
    cout<<sizeof (long)<<endl; //8
    cout<<sizeof (Base)<<endl; //8

    long* arr = (long*)*(long*)(&b);
    cout << "虚函数表地址：" << (long*)arr << endl;

    cout << "第一个虚函数地址：" << (long*)(arr[0]) << endl;
    cout << "第二个虚函数地址：" << (long*)(arr[1]) << endl;
    cout << "第三个虚函数地址：" << (long*)(arr[2]) << endl;
    pFun = (Fun)(arr[0]);
    pFun(); //Base::f

    //我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：
    ((Fun)(arr[1]))(); // Base::g()
    ((Fun)(arr[2]))(); // Base::h()
}

注意：在虚函数表的最后多加了一个结点，这是虚函数表的结束结点。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC4.1.3下，这个值是：如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。
一般继承（无虚函数覆盖）

请注意，在这个继承关系中，子类没有重载任何父类的函数。对于实例：Derive d; 的虚函数表如下：

我们可以看到下面几点：
1）虚函数按照其声明顺序放于表中。
2）父类的虚函数在子类的虚函数前面。
一般继承（有虚函数覆盖）

多重继承（无虚函数覆盖）
1）每个父类都有自己的虚表。
2）子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类指针指向同一个子类实例，能够调用到实际的函数。

多重继承（有虚函数覆盖）

三个父类虚函数表中的f()的位置被替换成了子类的函数指针。

安全性

一、通过父类型的指针访问子类自己的虚函数
虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但不可能使用下面的语句来调用子类的自有虚函数：
Base1 *b1 = new Derive();
b1->f1(); //编译出错

任何用父类指针调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。
二、访问non-public的虚函数
如果父类的虚函数是private或是protected的，这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数。
Fun pFun = (Fun)*((int*)*(int*)(&d)+0);
pFun();
我们可以在VC的IDE环境中的Debug状态下展开类的实例就可以看到虚函数表了（并不是很完整的）

原理

vptr（virtual table pointer，虚函数表指针）的指针的形式。vptr 指向一个被称为 vtbl（virtual table，虚函数表）的函数指针数组，每一个包含虚函数的类都关联到 vtbl。当一个对象调用了虚函数，实际的被调用函数通过下面的步骤确定：找到对象的 vptr 指向的 vtbl，然后在 vtbl 中寻找合适的函数指针。如果类定义了虚函数，该类及其派生类就要生成一张虚拟函数表，即vtable。而在类的对象地址空间中存储一个该虚表的入口，这个入口地址是在构造对象时由编译器写入的。所以，由于对象的内存空间包含了虚表入口，编译器能够由这个入口找到恰当的虚函数。

虚函数的缺点
虚函数最主要的缺点是执行效率较低，另外就是由于要携带额外的信息（VPTR），所以导致类占的内存空间也会比较大，对象也是一样的。
class A
{
private:
    int a;
    int b;
public:
    virtual void fun0()   {  cout<<"A::fun0"<<endl;   }
};
虚继承
对于虚继承，若派生类有自己的虚函数，则它本身需要有一个虚指针，指向自己的虚表。另外，派生类虚继承父类时，首先要通过加入一个虚指针来指向父类，因此有两个虚指针。
计算一个类对象的大小时的规律：
1、空类、单一继承的空类、多重继承的空类所占空间大小为：1（字节，下同）；
2、虚函数本身、成员函数和静态数据成员都是不占用类对象的存储空间的；
3、因此一个对象的大小≥所有非静态成员大小的总和；
4、当类中声明了虚函数，那么在实例化对象时，编译器会自动在对象里安插一个指针vfPtr指向虚函数表vfTable；

5、虚承继的情况：由于涉及到虚函数表和虚基表，会同时增加一个（多重虚继承下对应多个）vfPtr指针指向虚函数表vfTable和一个vbPtr指针指向虚基表vbTable，这两者所占的空间大小为：8（或8乘以多继承时父类的个数）；
7、类对象的大小=各非静态数据成员（包括父类的非静态数据成员）的总和+ vfptr指针(多继承下可能不止一个)+vbptr指针(多继承下可能不止一个)+编译器额外增加的字节。

class A{};  sizeof(A)<<endl;    //result=1

class B
{
    char ch;
    virtual void func0(){}
};     
sizeof(B)<<endl;    //result=8  

class C
{  
    char ch1;  
    char ch2;  
    virtual void func()  {  }
    virtual void func1()  {  } 
};
sizeof(C)<<endl;    //result=8  

class D: public A, public C  
{
    int d;  
    virtual void func()  {  }  
    virtual void func1()  {  }  
};       
sizeof(D)<<endl;    //result=12  

class E: public B, public C  
{     
    int e;     
    virtual void func0()  {  }   
    virtual void func1()  {  }  
};  
sizeof(E)<<endl;    //result=20

求sizeof(E)的时候，首先是类B的虚函数地址，然后类B中的数据成员，再然后是类C的虚函数地址，然后类C中的数据成员，最后是类E中的数据成员e，同样注意内存对齐，这样4+4+4+4+4=20。
示例二：含有虚继承

class CommonBase  
{      
    int co;  
};    

class Base1: virtual public CommonBase  
{  
public:  
    virtual void print1() {  }  
    virtual void print2() {  }  
private:  
    int b1;  
};    

class Base2: virtual public CommonBase  
{  
public:  
    virtual void dump1() {  }  
    virtual void dump2() {  }  
private:  
    int b2;  
};    

class Derived: public Base1, public Base2  
{  
public:  
    void print2() {  }  
    void dump2() {  }  
private:  
    int d;  
};  

//sizeof(Derived)=32，其在内存中分布的情况如下：
class Derived size(32):  
     +---  
     | +--- (base class Base1)  
 | | {vfptr}  
 | | {vbptr}  
 | | b1  
     | +---  
     | +--- (base class Base2)  
 | | {vfptr}  
 | | {vbptr}  
 | | b2  
    | +---  
 | d  
    +---  
    +--- (virtual base CommonBase)  
 | co  
    +---

示例3：

class A  
{  
public:  
    virtual void aa() {  }  
    virtual void aa2() {  } 
private:  
    char ch[3];  
};    
sizeof(A)<<endl;     8

class B: virtual public A  
{  
public:  
    virtual void bb() {  } 
    virtual void bb2() {  }  
};

对于虚继承，类B因为有自己的虚函数，所以它本身有一个虚指针，指向自己的虚表。另外，类B虚继承类A时，首先要通过加入一个虚指针来指向父类A，然后还要包含父类A的所有内容。因此是4+4+8=16。

不用虚函数实现多态
用函数指针来实现多态，这样做的好处主要是绕过了vtable。我们都知道虚函数表有时候会带来一些性能损失。
typedef void (*fVoid)();
class A
{
public:
    static void test()
{
printf("hello A\n");
}
    fVoid print;
    A()
{
print = A::test;
}
};

class B : public A
{
public:
    static void test()
{
printf("hello B\n");
}
    B()
{
print = B::test;
}
};

B b;
A* a = &b;
a->print();