目前最经典的关于虚函数的解释整理

最新推荐文章于 2022-10-17 19:36:25 发布

haizhongyun

最新推荐文章于 2022-10-17 19:36:25 发布

阅读量631

点赞数

分类专栏：设计模式 c++ 文章标签： hex class fun 编译器 linux c

c++ 同时被 2 个专栏收录

26 篇文章 0 订阅

订阅专栏

设计模式

12 篇文章 0 订阅

订阅专栏

自己也曾经被这些东西所困惑过，看见这篇文章写的不错，转载了过来，希望能给同样的迷茫中的人一点线索，仅供参考！（唯一不足之处就是应该把内存示意图贴出来就好多了，有时间我补上）

[1]C++ 对象模型基础

一个类中可以包含静态数据成员、静态成员函数、非静态成员函数和非静态数据成员以及虚函数。其中，前三者（静态数据成员、静态成员函数、非静态成员函数）都并没有被放到对象的布局中，可以从以下两段代码得到验证：

view plaincopy to clipboardprint?
#include <iostream>
using namespacestd;

class Base{
};

int main(){
    Base a;
    cout << sizeof (a)<< endl;//输出1
    return 0;
}
#include <iostream>
using namespace std;

class Base {
};

int main(){
    Base a;
    cout << sizeof (a)<< endl;// 输出1
    return 0;
}

上述的 Base 类是一个空类，占据了一个字节的内存空间，这是为了保证每个类实例化后都拥有独一无二的内存空间。接着我们往Base 类中添加静态数据成员、静态成员函数和非静态成员函数：

view plaincopy to clipboardprint?
#include <iostream>
using namespacestd;

class Base{
public :
    Base(){}
    ~Base(){}
    static intv1;
    static voidf1(){}
    void f2(){}
};

int main(){
    Base a;
    cout << sizeof (a)<< endl;//仍然输出1
    return 0;
}
#include <iostream>
using namespace std;

class Base {
public :
    Base(){}
    ~Base(){}
    static int v1;
    static void f1(){}
    void f2(){}
};

int main(){
    Base a;
    cout << sizeof (a)<< endl;// 仍然输出1
    return 0;
}

在经过内容填充后， Base 类的实例 a 仍然仅占据 1个字节的内存空间，与空类无异，这说明了静态数据成员、静态成员函数和非静态成员函数并未被放在对象的内存布局当中。

接下来往类中添加非静态数据成员：

view plaincopy to clipboardprint?
#include <iostream>
using namespacestd;

class Base{
public :
    int a;
    int b;
};

int main(){
    Base a;
    cout << sizeof (a)<< endl;//输出8
    cout << hex<< &a<< endl;// 输出0012F3CC
    cout << hex<< &a.a<< endl;// 输出0012F3CC
    cout << hex<< &a.b<< endl;// 输出0012F3D0
    return 0;
}
#include <iostream>
using namespace std;

class Base {
public :
    int a;
    int b;
};

int main(){
    Base a;
    cout << sizeof (a)<< endl;// 输出8
    cout << hex<< &a<< endl;// 输出0012F 3CC
    cout << hex<< &a.a<< endl;// 输出0012F 3CC
    cout << hex<< &a.b<< endl;// 输出0012F 3D0
    return 0;
}

从上面的代码可以看出：一，非静态数据成员是会被放到对象的内存布局中；二，数据成员是根据声明顺序有序地在内存中进行分布的；三，在没有虚函数的情况下对象所占据的内存大小就是数据成员所占据的空间之和。布局如下图：

a

b

那么如果添加了虚函数以后呢？先看一段代码：

view plaincopy to clipboardprint?
#include <iostream>
using namespacestd;

class Base{
public :
    int a;
    int b;
    void doit(){}
protected :
    virtual void vf(){ cout << "hi"<< endl;}
    virtual voidvf_(){}
};

int main(){
    Base a;
    cout << sizeof (a)<< endl;//输出12
    cout << hex<< &a<< endl;// 输出0012F 3C8
    cout << hex<< &a.a<< endl;// 输出0012F3CC
    cout << hex<< &a.b<< endl;// 输出0012F3D0
    return 0;
}
#include <iostream>
using namespace std;

class Base {
public :
    int a;
    int b;
    void doit(){ }
protected :
    virtual void vf(){ cout << "hi"<< endl; }
    virtual void vf_(){}
};

int main(){
    Base a;
    cout << sizeof (a)<< endl;// 输出12
    cout << hex<< &a<< endl;// 输出0012F 3C 8
    cout << hex<< &a.a<< endl;// 输出0012F 3CC
    cout << hex<< &a.b<< endl;// 输出0012F 3D0
    return 0;
}

Base 基类中有两个虚函数，这两个虚函数（如果只有一个虚函数情况也一样）出现后使得对象 a 的大小变为 12，相较于没有虚函数的情况多了 4 个字节，即 32 位，相当于一个指针所占的内存大小。

包含虚函数的类的对象实例中会在内存布局中多添加了一个 vptr 指针，这个指针指向（不仅）存放虚函数地址的虚表 vtbl，所以不管类中只有一个虚函数或者有多个，在对象实例中只会多出一个指针需要的空间大小，即 4 个字节。

此外， vptr 通常存放在对象内存布局中的起始处。从上一段代码输出的地址就可以看出成员变量 a 占据 0012F 3CC 到0012F 3CF 的空间，成员变量 b 占据 0012F 3D0 到 0012F 3D3 的空间，而对象首址 0012F 3C 8到 0012F 3CB 则是用来存放 vptr 的。总计 12 字节，布局如下图：

vptr

a

b

[2] 继承关系下的模型和指针类型

在单继承的情况下，对象实例的内存布局中，基类部分位于子类部分前；而对于多继承，不同的基类部分会按照继承声明顺序在内存中陆续分布。如下是一个代码示例：

view plaincopy to clipboardprint?
#include <iostream>
using namespacestd;

class Base{
public :
    void doit(){ vf();}
    int bv;
protected :
    virtual void vf(){ cout << "Base"<< endl;}
};

class Base1{
public :
    void doit1(){ vf1();}
    int b1v;
protected :
    virtual void vf1(){ cout << "Base1"<< endl;}
};

class Demo : public Base, public Base1{
protected :
    void vf(){ cout << "Demo"<< endl;}
    virtual void vf1(){ cout << "Demo1"<< endl;}
    virtual voidvf2(){}
public :
    int dv;
};

int main(){
    Demo d;
    cout << sizeof (d)<< endl;//输出
    cout << hex<< &d<< endl;//输出F3B8
    cout << hex<< &d.bv<< endl;//输出F3BC
    cout << hex<< &d.b1v<< endl;//输出F3C4
    cout << hex<< &d.dv<< endl;//输出F3C8
    Base *p =&d;
    p->doit();// 输出Demo，即执行子类重写的虚函数
    cout << hex<< p <<endl;//输出F3B8
    Base1 *p1 =&d;
    cout << hex<< p1<< endl;//输出F3C0
    return 0;
}
#include <iostream>
using namespace std;

class Base {
public :
    void doit(){ vf(); }
    int bv;
protected :
    virtual void vf(){ cout << "Base"<< endl; }
};

class Base1 {
public :
    void doit1(){ vf1(); }
    int b1v;
protected :
    virtual void vf1(){ cout << "Base1"<< endl; }
};

class Demo : public Base, public Base1 {
protected :
    void vf(){ cout << "Demo"<< endl; }
    virtual void vf1(){ cout << "Demo1"<< endl; }
    virtual void vf2(){}
public :
    int dv;
};

int main(){
    Demo d;
    cout << sizeof (d)<< endl;// 输出
    cout << hex<< &d<< endl;// 输出F3B8
    cout << hex<< &d.bv<< endl;// 输出F3BC
    cout << hex<< &d.b1v<< endl;// 输出F3C4
    cout << hex<< &d.dv<< endl;// 输出F3C8
    Base *p = &d;
    p->doit();// 输出Demo ，即执行子类重写的虚函数
    cout << hex<< p <<endl;// 输出F3B8
    Base1 *p1 = &d;
    cout << hex<< p1<< endl;// 输出F3C0
    return 0;
}

Base 基类因为有一个 vptr 和一个数据成员 bv ，所以占据了 8 个字节； Base1 基类同样有 vptr和数据成员 b1v ，所以也占据了 8 个字节；而子类 Demo 继承了 Base 和 Base1 ，又新增了一个数据成员 dv，所以总共占据了 20 个字节的空间。

对象 d 占据了从 0012F 3B8 到 0012F 3CB 的 20 个字节内存空间，其中 Base 基类的部分位于0012F 3B8 到 0012F 3BF 的 8 个字节， Base1 基类部分紧随其后，占据 0012F 3C 0 到 0012F3C 7 的内存空间，最后是子类本身的数据成员 dv 。布局如下图所示：

vptr_Base

bv

vptr_Base1

b1v

dv

注意到指针 p 和 p1 的声明和赋值，以及所指向的首址。指针 p 的类型是 Base * ，它指向了对象 d 中的 Base基类部分；指针 p1 的类型是 Base1 * ，它指向了对象 d 中的 Base1部分。指针类型的作用是给予编译器信息，表明指针指向的对象类型（包含首址以及大小等信息），因为子类中含有基类部分，所以基类指针可以指向子类，更实质地讲是指向子类中的基类部分。

既然 Base * 类型的指针指向的是内存中 Base 基类的部分，那么为什么运行下述语句会执行子类中的虚函数呢？

view plaincopy to clipboardprint?
Base *p =&d;
p->doit();// 输出Demo，即执行子类重写的虚函数
    Base *p = &d;
    p->doit();// 输出Demo ，即执行子类重写的虚函数

首先我们确定指针 p 能访问的只有 vptr_Base 和 bv 这两个成员，其中 vptr_Base指向一个虚表，虚表中存放着类型信息和虚函数的地址。这里不妨认为 vptr_Base[1] 存放着虚函数 vf 的地址。

在编译阶段可以针对虚函数机制做的工作有：一，确定虚表的地址，即 vptr的指向；二，确定虚表的大小和内容；三，针对不同虚函数的调用，转换为对虚表不同表项的索引。在确定虚表的内容时，如果子类重写了基类的虚函数，那么虚表中对应的表项会被修改指向子类重新实现的函数地址；否则的话，仍旧指向基类中定义的虚函数。

在上述代码中，由于 Demo 类中重写了虚函数 vf ，所以 vptr_Base[1] 指向了子类中的虚函数实体，而非 Base中定义的 vf 。

经过编译后，我们知道对 vf 函数的调用相当于调用 vptr_Base[1]所指向的函数，但是在这个阶段无法知道调用的虚函数到底是基类定义的还是子类中重写的，因为 Base * 类型的指针可以指向一个 Base类型对象，也可以指向子类 Demo 中的 Base 基类部分。因此，只有在执行期才可以知道 vptr_Base[1] 到底指向哪一个vf 函数实体。

[3] 编码层次的虚函数

如果基类希望某个成员函数由子类重定义，那么应该将其声明为 virtual类型。虚函数是动态绑定的基础，（只有）通过基类类型的指针或引用进行虚函数的调用才可以触发动态绑定，这体现了多态这一面向对象的关键思想。可以看出，基类类型的指针或引用既可以指向基类类型对象也可以指向子类类型对象的特性是动态绑定的关键。

通过虚函数可以实现运行时多态，这有利于公共接口的实现。即在继承体系中处于不同层次的类使用同一接口，但运行时会根据具体对象类型的差异而采取不同的策略。这种风格在良好的软件体系结构可以经常发现，比如Qt 。

在实际编码设计过程中需要注意以下几点：

1、要发生动态绑定，实现运行时的多态，需要通过基类的指针或者引用调用虚函数，这样在运行时才会根据指针或引用所指向的对象的实际类型调用相应的目标函数。

2、关键字 virtual只能在类内部的成员声明中出现，而不能出现在类定义体外部。

3、一经声明为虚函数，则一直是虚函数；子类可以不用显示声明 virtual，但虚函数的特性不会改变。

4、子类中虚函数的声明必须和基类的定义方式匹配，除了基类中虚函数返回对基类类型的指针或引用，在这种情况下，子类中的虚函数可以返回基类函数所返回类型的子类的指针或引用。

5、子类中虚函数调用基类的虚函数必须使用显示作用域声明，或者会递归调用自身。

6、纯虚函数仅作为抽象接口以供覆盖，包含纯虚函数的类是抽象基类，不能被实例化。

下面是另外一篇文章，正好有上一篇文章没有的虚表结构图，虽然例子不同，当时殊途同归！（再次转载过来，我也就不用自己动手画图了，哈哈哈……两篇文章对比阅读，相信能有豁然开朗之感！！！在这里感谢原作者）

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

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。而在Ubuntu7.10 + Linux 2.6.22 + GCC4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

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

一般继承（无虚函数覆盖）

下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：