C++基于虚函数的多态分析

关注

原创最新推荐文章于 2025-11-10 11:22:09 发布 550 阅读 AI 写同款· GEO 优化 ›

AI权益加码！Claude Code、Cursor等20+工具免费用！购周边限时加赠Coding Plan Lite，畅享主流AI工具！学习进阶更高效！阅读详情

本文只是讨论运行时多态(虚函数)

关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，(怎么个多种形态，就是父类型的指针，有时候可以解引用而调父类方法(当此方法不是虚函数)，有时候可以调到子类方法(虚函数价值体现))，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。

我们先来讨论一下类有无虚函数对于的实例大小有什么影响来引出虚函数表

#include<iostream>
using namespace std;

class Empty{
};

class NoVirtualBase
{
public:
NoVirtualBase() {};
~NoVirtualBase() { cout << "Output from the destructor of class NoVirtualBase!" << endl; };
void DoSomething() { cout << "no virtual Do something in class NoVirtualBase!" << endl; };
private:
int a;
};

class VirtualBase
{
public:
VirtualBase() {};
virtual ~VirtualBase() { cout << "Output from the destructor of class VirtualBase" << endl; };
virtual void DoSomething() { cout << " virtual Dosomething in class VirtualBase" << endl; };
private:
int a;
};

class PurlBase
{
public:
PurlBase() {};
virtual void DoSomething()=0;

private:
int a;
};

class Derive : public VirtualBase
{
public:
Derive() {};
~Derive() { cout << "Output from the destructor of class Derive!" << endl; };
virtual void DoSomething() { cout << "Do something in class Derive!" << endl; };//加不加上virtual关键字都没问题，不加也是一个对>基类doSomething的覆盖，只是加上代码更清晰明了。
};

int main()
{
//check sizeof each class
cout << "sizeof(Empty)=" << sizeof(Empty) <<endl;
cout << "sizeof(NoVirtualBase)=" << sizeof(NoVirtualBase) <<endl;
cout << "sizeof(VirtualBase)=" << sizeof(VirtualBase) <<endl;
cout << "sizeof(PurlBase)=" << sizeof(PurlBase) <<endl;
return 0;
}

1，为什么sizeof(Empty)=1？
类的实例化，所谓类的实例化就是在内存中分配一块地址，每个实例在内存中都有独一无二的地址。同样空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的sizeof为1，对于不同的编译器也可能会是4。

2，为什么siozeof(NoVirtualBase)=4?
成员函数也是函数，函数都是有地址的，所以函数是占用内存空间的，但函数由于是多对象共享的，所以函数不占用对象的内存地址，是放在代码段的；
那么static 数据成员呢？具有相似性，他也属于类的，所以sizeof时也要去掉这个的计算，最后只有普通数据成员才能计算在内，等于4

3，sizeof(VirtualBase) =8
为什么等于8，一个int 4字节，加一个指向虚表(V-TABLE)的指针VPTR，不管是一个虚函数还是多个，只有一个vptr,只指向一个v-table，所以算作一个指针4字节。

4,sizeof(PurlBase)=8
纯虚函数的类也有一个虚表，但是这个类不能实例化。此为抽象类。

编译器对每个包含虚函数的类创建一个表或多个(多继承)，称为V TA B L E。每个对象都是都有一个或多个VPTR，指向这个虚表。在V TA B L E中，编译器放置特定类的虚函数地址。通过基类指针做虚函数调用时（也就是做多态调用时），编译器静态地插入取得这个V P T R，并在V TA B L E表中查找函数地址的代码，这样就能调用正确的函数使动态联编发生。为每个类设置V TA B L E、初始化V P T R、为虚函数调用插入代码，所有这些都是自动发生的(VTPR的初始化是发生在构造函数时，destroy在析构。所以万不用到malloc一个含有虚函数的对象，而要用到new,其实有很多说法是：vtpr的初始化是编译器所关心的，实现的，不一定放在构造函数里面。大部分的编译器实现是放在构造函数后面，其它代码之前，众说纷纭，C++也没有规范。)，所以我们不必担心这些。利用虚函数，这个对象的合适的函数就能被调用，哪怕在编译器还不知道这个对象的特定类型的情况下。（《C++编程思想》）

在任何类中不存在显示的类型信息，可对象中必须存放类信息，否则类型不可能在运行时建立。那这个类信息是什么呢？我们来看下面几个类：

class no_virtual
{
public:
void fun1() const{}
int fun2() const { return a; }
private:
int a;
}

class one_virtual
{
public:
virtual void fun1() const{}
int fun2() const { return a; }
private:
int a;
}

class two_virtual
{
public:
virtual void fun1() const{}
virtual int fun2() const { return a; }
private:
int a;
}

以上三个类中：
no_virtual没有虚函数，sizeof(no_virtual)=4，类no_virtual的长度就是其成员变量整型a的长度；
one_virtual有一个虚函数，sizeof(one_virtual)=8；
two_virtual 有两个虚函数，sizeof(two_virtual)=8；有一个虚函数和两个虚函数的类的长度没有区别，其实它们的长度就是no_virtual的长度加一个void指针的长度，它反映出，如果有一个或多个虚函数，编译器在这个结构中插入一个指针（ V P T R）。在one_virtual 和two_virtual之间没有区别。这是因为V P T R指向一个存放地址的表，只需要一个指针，因为所有虚函数地址都包含在这个表中。

这个VPTR就可以看作类的类型信息。

那我们来看看编译器是怎么建立VPTR指向的这个虚函数表的。先看下面两个类：
class base
{
public:
void bfun(){}
    virtual void vfun1(){}
virtual int vfun2(){}
private:
int a;
}

class derived : public base
{
public:
void dfun(){}
    virtual void vfun1(){}
virtual int vfun3(){}
private:
int b;
}

两个类VPTR指向的虚函数表（VTABLE）分别如下：
base类
——————
VPTR——> |&base::vfun1 |
——————
|&base::vfun2 |
——————

derived类
———————
VPTR——> |&derived::vfun1 |
———————
|&base::vfun2    |
———————
|&derived::vfun3 |
———————
每当创建一个包含有虚函数的类或从包含有虚函数的类派生一个类时，编译器就为这个类创建一个VTABLE，如上图所示。在这个表中，编译器放置了在这个类中或在它的基类中所有已声明为virtual的函数的地址。如果在这个派生类中没有对在基类中声明为virtual的函数进行重新定义，编译器就使用基类的这个虚函数地址。（在derived的VTABLE中，vfun2的入口就是这种情况。）然后编译器在这个类中放置VPTR。当使用简单继承时，对于每个对象只有一个VPTR。VPTR必须被初始化为指向相应的VTABLE，这在构造函数中发生。
一旦VPTR被初始化为指向相应的VTABLE，对象就"知道"它自己是什么类型。但只有当虚函数被调用时这种自我认知才有用。

VPTR常常位于对象的开头，编译器能很容易地取到VPTR的值，从而确定VTABLE的位置。VPTR总指向VTABLE的开始地址，所有基类和它的子类的虚函数地址（子类自己定义的虚函数除外）在VTABLE中存储的位置总是相同的，如上面base类和derived类的VTABLE中 vfun1和vfun2的地址总是按相同的顺序存储。编译器知道vfun1位于VPTR处，vfun2位于VPTR+1处，因此在用基类指针调用虚函数时，编译器首先获取指针指向对象的类型信息（VPTR），然后就去调用虚函数。如一个base类指针pBase指向了一个derived对象，那 pBase->vfun2()被编译器翻译为 VPTR+1 的调用，因为虚函数vfun2的地址在VTABLE中位于索引为1的位置上。同理，pBase->vfun3()被编译器翻译为VPTR+2的调用。这就是所谓的晚绑定。

我们来看一下虚函数调用的汇编代码，以加深理解。
void test(base* pBase)
{
pBase->vfun2();
}

int main(int argc, char* argv[])
{
derived td;
test(&td);
return 0;
}

derived td;编译生成的汇编代码如下：
mov DWORD PTR _td$[esp+24], OFFSET FLAT:??_7derived@@6B@ ; derived::`vftable'
由编译器的注释可知，此时PTR _td$[esp+24]中存储的就是derived类的VTABLE地址。

test(&td);编译生成的汇编代码如下：
lea eax, DWORD PTR _td$[esp+24]
mov DWORD PTR __$EHRec$[esp+32], 0
push eax
call ?test@@YAXPAVbase@@@Z   ; test
调用test函数时完成了如下工作：取对象td的地址，将其压栈，然后调用test。
pBase->vfun2();编译生成的汇编代码如下：
mov ecx, DWORD PTR _pBase$[esp-4]
mov eax, DWORD PTR [ecx]
jmp DWORD PTR [eax+4]
首先从栈中取出pBase指针指向的对象地址赋给ecx，然后取对象开头的指针变量中的地址赋给eax，此时eax的值即为VPTR的值，也就是 VTABLE的地址。最后就是调用虚函数了，由于vfun2位于VTABLE的第二个位置，相当于 VPTR+1，每个函数指针是4个字节长，所以最后的调用被编译器翻译为 jmp DWORD PTR [eax+4]。如果是调用pBase->vfun1()，这句就该被编译为jmp DWORD PTR [eax]。

虚函数表

对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。编译器对每个包含虚函数的类创建一个表（称为V TA B L E）, 在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。一个类的虚函数表是静态的，也就是说对这个类的每个实例，他的虚函数表的是固定的，不会为每个实例生成一个相应的虚函数表。虚函数表就像我们上面讨论的，它在代码段，归属于类，而非对象，指向虚表的指针才在实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

这里我们着重看一下这张虚函数表。在C++的标准规格说明书中说到，编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数表中的函数地址的偏移量）。这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

假设我们有这样的一个类：

class Base {

public:

virtual void f() { cout << "Base::f" << endl; }

virtual void g() { cout << "Base::g" << endl; }

virtual void h() { cout << "Base::h" << endl; }

};

按照上面的说法，我们可以通过Base的实例来得到虚函数表。下面是实际例程：

typedef void(*Fun)(void);

Base b;

Fun pFun = NULL;

cout << "实例地址：" << (int*)(&b) << endl;

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

// Invoke the first virtual function

pFun = (Fun)*((int*)*(int*)(&b));//这个才是第一个虚函数的地址

pFun();

实际运行经果如下：(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)

虚函数表地址：0012FED4

虚函数表 — 第一个函数地址：0044F148

Base::f

通过这个示例，我们可以看到，我们可以通过强行把&b转成int *，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int* 强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：

(Fun)*((int*)*(int*)(&b)+0); // Base::f()

(Fun)*((int*)*(int*)(&b)+1); // Base::g()

(Fun)*((int*)*(int*)(&b)+2); // Base::h()

这个时候你应该懂了吧。什么？还是有点晕。也是，这样的代码看着太乱了。没问题，让我画个图解释一下。如下所示：

注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。