C++虚函数，虚函数表，虚继承，虚继承表

最新推荐文章于 2021-10-03 12:34:29 发布
最新推荐文章于 2021-10-03 12:34:29 发布
阅读量918 收藏 10
点赞数 5
文章标签： C++ 多态 虚函数 虚继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42436161/article/details/115707469
版权

一、虚函数

类中用virtual关键字修饰的函数。

作用：主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。

class Vfptr_classA{
public:
    virtual void function1(){
        cout<<"function1"<<endl;
    }
    virtual void function2(){
        cout<<"function2"<<endl;
    }
};

二、虚函数表

1、虚函数表格大小

先看空类的大小

//空类
class Vfptr_classA{
};

int main(){
    
    Vfptr_classA Vfptr_A;

    cout << "sizeof Vfptr_A :" << sizeof(Vfptr_A) <<endl;
    return 0;
}


##打印
sizeof Vfptr_A :1

2、有一个虚函数的类

//有一个虚函数的类
class Vfptr_classA{
public:
    virtual void function1(){
        cout<<"function1"<<endl;
    }
};

int main(){
    
    Vfptr_classA Vfptr_A;

    cout << "sizeof Vfptr_A :" << sizeof(Vfptr_A) <<endl;
    return 0;
}


##打印
sizeof Vfptr_A :4

3、有2个虚函数的类

//虚函数表 Vfptr
class Vfptr_classA{
public:
    virtual void function1(){
        cout<<"function1"<<endl;
    }
    virtual void function2(){
        cout<<"function2"<<endl;
    }
};

int main(){
    
    Vfptr_classA Vfptr_A;

    cout << "sizeof Vfptr_A :" << sizeof(Vfptr_A) <<endl;
    return 0;
}


##打印
sizeof Vfptr_A :4

由此可以正式，类在内存中记录虚函数是以一个指针记录的，并且该指针指向一个数组，数组中装着的是虚函数的地址。同时，经过实验，发现32bit的编译器下，虚函数表的指针大小是4字节。64bit的编译器下，虚函数表的指针大小是8字节。

2、虚函数表在类内存中的位置

首先我们通过代码分析一下：

//虚函数表 Vfptr
class Vfptr_classA{
public:
    int a;
    virtual void function1(){
        cout<<"function1"<<endl;
    }
    virtual void function2(){
        cout<<"function2"<<endl;
    }

    void show(){
        cout<<"show"<<endl;
    }

};

int main(){
//虚函数表
    Vfptr_classA Vfptr_A;
    cout << "address Vfptr_A :" << &Vfptr_A <<endl;
    cout << "address Vfptr_A.a :" << &Vfptr_A.a <<endl;
return 0;
}

##打印
address Vfptr_A :00EFF9F8
address Vfptr_A.a :00EFF9FC

可以看到，成员变量到类的首地址有4个字节（虚函数表指针），成员变量的地址在虚函数表后，由此可以通过取类变量地址的方式获取虚函数表地址。

会有同学问，如果有成员函数呢？？成员函数不占用对象的内存。这是因为所有的函数都是存放在代码区的，不管是全局函数，还是成员函数。

 

3、如何利用虚函数表调用虚函数

直接上代码

//虚函数表 Vfptr
class Vfptr_classA{
public:
    virtual void function1(){
        cout<<"function1"<<endl;
    }
    virtual void function2(){
        cout<<"function2"<<endl;
    }
};

typedef void (*fun)();  //定义函数指针



int main(){

//虚函数表
    Vfptr_classA Vfptr_A;

    int * Vfptr_As = (int *)(*((int *)&Vfptr_A)); //获取虚函数表
    //实际上是一个数组
    for(int i = 0 ; Vfptr_As[i] != 0 ; ++i){
        cout<< "fptr "<< i <<"address :"<<Vfptr_As[i] <<endl;
        fun f = (fun)Vfptr_As[i];
        f();
    }

    return 0;
}

##打印
fptr 0address :11080325
function1
fptr 1address :11080335
function2

注意：以上代码为32位，虚函数表指针为4字节。而若用64为编译器运行，则会获取地址失败，原因是64位编译器时，虚函数表指针为8字节，需要用long long类型指针获取。

    Vfptr_classA Vfptr_A;
    long long * Vfptr_As = (long long *)(*((long long *)&Vfptr_A));
    cout<< "Vfptr :"<<Vfptr_As<<endl;
    for(int i = 0 ; Vfptr_As[i] != 0 ; ++i){
        cout<< "fptr "<< i <<"address :"<<Vfptr_As[i] <<endl;
        fun f = (fun)Vfptr_As[i];
        f();
    }

##打印
fptr 0address :140695608234229
function1
fptr 1address :140695608233989
function2

4、继承类多态（虚函数重写）

1、继承

class Vfptr_classA{
public:
    virtual void function1(){
        cout<<"function1"<<endl;
    }
    virtual void function2(){
        cout<<"function2"<<endl;
    }
};

class Vfptr_classB : public Vfptr_classA{
public:
    virtual void function3(){
        cout<<"function3"<<endl;
    }

    int  b;
};

##主函数执行
    Vfptr_classB Vfptr_B;
    cout << "sizeof Vfptr_B :" << sizeof(Vfptr_B) <<endl;
    cout << "address Vfptr_B :" << &Vfptr_B <<endl;
    cout << "address Vfptr_B.b :" << &Vfptr_B.b <<endl;


##打印
sizeof Vfptr_B :8
address Vfptr_B :009DFB74
address Vfptr_B.b :009DFB78

由上可知，派生类B在头部也有一张虚函数表，大小为4字节（32bit），成员变量在后。而通过调试看

发现，派生类头部共用基类的虚函数列表，而派生类新增加的虚函数会保存在基类的虚函数后面。

2、重写

class Vfptr_classB : public Vfptr_classA{
public:
    virtual void function3(){
        cout<<"function3"<<endl;
    }
     void function1(){
        cout<<"ClassB function1"<<endl;
    }

    int  b;
};



##主函数执行
int main(){
    Vfptr_classB Vfptr_B;

    int * Vfptr_Bs = (int *)(*((int *)&Vfptr_B));
    cout<< "Vfptr :"<<Vfptr_Bs<<endl;
    for(int i = 0 ; Vfptr_Bs[i] != 0 ; ++i){
        cout<< "fptr "<< i <<"address :"<<Vfptr_Bs[i] <<endl;
        fun f = (fun)Vfptr_Bs[i];
        f();
    }
    return 0;
}
##打印
fptr 0address :8589982
ClassB function1
fptr 1address :8589957
function2
fptr 2address :8589637
function3

发现变化了，由打印顺序看，由于派生类B重写了基类A的function1，重写后的函数会被替换到虚函数列表中基类A的function1的位置。看一下调试

证实了我们的猜测。

3、多重继承

1、重写一个基类的虚函数

class Vfptr_classA{
public:
    virtual void function1(){
        cout<<"function1"<<endl;
    }
    virtual void function2(){
        cout<<"function2"<<endl;
    }
};

class Vfptr_classC{
public:
    virtual void function4(){
        cout<<"function4"<<endl;
    }
};
class Vfptr_classB : public Vfptr_classA , public Vfptr_classC{
public:
    virtual void function3(){
        cout<<"function3"<<endl;
    }
     void function1(){
        cout<<"ClassB function1"<<endl;
    }

    int  b;
};



int main(){

    Vfptr_classB Vfptr_B;
    cout << "sizeof Vfptr_B :" << sizeof(Vfptr_B) <<endl;
    cout << "address Vfptr_B :" << &Vfptr_B <<endl;
    cout << "address Vfptr_B.b :" << &Vfptr_B.b <<endl;
    return 0;
}


##打印
sizeof Vfptr_B :12
address Vfptr_B :00B3F74C
address Vfptr_B.b :00B3F754

 

打开调试内存

可以看到，此时在B的内存中，头部是基类A的虚函数表，跟着的是基类B的虚函数表，它们各占用4个字节。同时，重写基类A的function1函数，会覆盖原来基类A的function1函数在虚函数表的位置。

猜想：在B中重写基类C的function4，是否也会覆盖基类C中的funciton4在虚函数表的位置？？好，我们继续做实验。

2、重写两个基类中的虚函数

class Vfptr_classA{
public:
    virtual void function1(){
        cout<<"function1"<<endl;
    }
    virtual void function2(){
        cout<<"function2"<<endl;
    }
};

class Vfptr_classC{
public:
    virtual void function4(){
        cout<<"function4"<<endl;
    }
};
class Vfptr_classB : public Vfptr_classA , public Vfptr_classC{
public:
    virtual void function3(){
        cout<<"function3"<<endl;
    }
     void function1(){
        cout<<"ClassB function1"<<endl;
    }
     void function4(){
        cout<<"ClassB function4"<<endl;
    }

    int  b;
};



int main(){

    Vfptr_classB Vfptr_B;
    cout << "sizeof Vfptr_B :" << sizeof(Vfptr_B) <<endl;
    cout << "address Vfptr_B :" << &Vfptr_B <<endl;
    cout << "address Vfptr_B.b :" << &Vfptr_B.b <<endl;
    return 0;
}


##打印
sizeof Vfptr_B :12
address Vfptr_B :00B3F74C
address Vfptr_B.b :00B3F754

猜想没错。

总结：

虚函数是动态多态（程序运行时多态，重载为静态多态）。实现方式为：

1、当类自身有虚函数，则会创建一张虚函数表，放置于类的开头，占用4个字节内存（64位为8bit）。

2、当类的父类中有虚函数，则派生类会继承父类的虚函数表，同时若派生类有新的虚函数，则会在父类的虚函数表后面追加。

3、当派生类为多重继承，并且多个父类都有虚函数，则会全部继承父类的虚函数表，顺序以继承顺序，并且派生类中新增的虚函数只会添加在第一个父类虚函数表中。

4、当派生类重写父类的虚函数，则重写后的函数会取缔原来虚函数在虚函数表中的位置。

 

 

4、虚函数运用时的理解

接着上，3.2（重写两个基类中的虚函数）中的例子

主程序中执行

##主程序中执行
    Vfptr_classA * ptrA = new Vfptr_classB();
    ptrA ->function1();

##打印
ClassB function1

猜想：

声明一个基类A的指针ptrA ，实例化出派生类B的对象。

而ptrA 指针类型是基类A，则只能索引到派生类B中的基类A的部分：

即此时，ptrA 应该指向的是派生类B中函数列表

 

但是

当我们调试的时候发现

ptrA指针指向B的整个内存空间，只是不能通过

这种方式调用其他派生类的函数。虽然我们依然可以通过地址偏移，找到B空间的第二张表（基类C的虚函数表），但不建议这样用，代码可读性变差。

    Vfptr_classA * ptrA = new Vfptr_classB();

    int * Vfptr_Bs = (int *)(*((int *)ptrA + 1));        //通过把(int *)ptrA + 1来获取下一张表
    for(int i = 0 ; Vfptr_Bs[i] != 0 ; ++i){
        cout<< "fptr "<< i <<"address :"<<Vfptr_Bs[i] <<endl;
        fun f = (fun)Vfptr_Bs[i];
        f();
    }

 

三、虚继承

虚继承和虚函数不相关！！！

虚继承是喂了解决菱形继承问题的一种手段。

1、菱形继承问题

class Vbptr_classA{
public:
    int a;
};

class Vbptr_classB : public Vbptr_classA{
public:
    int b;
};

class Vbptr_classC : public Vbptr_classA{
public:
    int c;
};

class Vbptr_classD : public Vbptr_classB , Vbptr_classC{
public:
    int d;
};

int main()
{
    Vbptr_classD D;
    D.a = 1;
    return 0;
}

当D调用基类A中的a成员，则会报错

原因是：D实例化时会先实例化B,C 。B,C实例化又会先实例化基类A，则最终，D中会存在两个int a；

2、虚继承

class Vbptr_classA{
public:
    int a;
};

class Vbptr_classB : virtual public Vbptr_classA{
public:
    int b;
};

class Vbptr_classC : virtual public Vbptr_classA{
public:
    int c;
};

class Vbptr_classD : public Vbptr_classB , Vbptr_classC{
public:
    int d;
};


int main()
{
   Vbptr_classD D;
    return 0;
}

观察内存

一看，同样是B里面有A，C里面也有A，后面多了一个基类A。但是细心的就可以发现，B中的A的地址与C中A的地址是与最后面的基类A的地址是一致的。所以我们可以得出结论，以这种方式的虚继承时，B和C中会创建一张虚基表，记录的是基类A的位置，记录方式是以地址+偏移量的方式记录，而真正A的实例化部分会放在最后。则由此就可以解决空间拷贝的问题。

3、虚基表（虚表）的理解

未写完。。

 

 

赟赟赟
关注
继承里既有虚继承也有虚函数继承（即既有虚基表，也有虚函数表）
sophia__yu的博客
10-14 337
菱形继承
c++中虚继承机制 内存布局
echoes_of_rainbow的专栏
10-17 398
http://www.cnblogs.com/itech/archive/2009/03/01/1399996.html [C++对象模型][9]虚继承与虚函数表 一 虚继承 1) 代码： Code #include iost
虚继承与虚函数表
smilestone322的专栏
08-21 1509
http://www.cnblogs.com/itech/archive/2009/02/27/1399996.html
[C++对象模型][9]虚继承与虚函数表
weixin_34107955的博客
03-01 81
一 虚继承 1) 代码： Code#include &lt;iostream&gt;using namespace std;class B{public:    int i;    virtual void vB(){ cout &lt;&lt; "B::vB" &lt;&lt; endl; }    void fB(){ cout &lt;&lt; "B::fB" &lt;&lt; 
虚继承和虚函数继承
肖氏专栏
06-13 1169
虚继承是为了在多继承的时候避免引发歧义，  比如类Ａ有个就是a,Ｂ继承了Ａ，C也继承了Ａ，当Ｄ多继承Ｂ，Ｃ时，就会有歧义产生了，所以要使用虚拟继承避免重复拷贝。  虚函数继承是解决多态性的，当用基类指针指向派生类对象的时候，基类指针调用虚函数的时候会自动调用派生类的虚函数，这就是多态性，也叫动态编联 虚函数继承：  class A  {  virtu
C++虚函数表实例分析
01-21
在对象中，有一个指针指向一张虚函数表，里面按照次序存放了每一个虚函数，当子类继承的时候，即到虚函数表的指定位置去修改函数地址。当我们通过父类指针来操作一个子类的时候，调用虚函数，都是通过虚函数表+固定...
C++虚函数及虚函数表简析
09-03
总之，C++的虚函数和虚函数表是实现多态性的重要工具，它们允许我们在不知道对象具体类型的情况下调用适当的方法，增强了代码的通用性和可扩展性。理解虚函数的原理和使用限制对于编写高效、可靠的C++代码至关重要。
C++ 多态 虚函数 虚函数表 最是详细
10-01
高质量的C++多态讲解，详细讲解虚函数，虚函数表，虚函数继承，虚函数继承下的内存分配等
C++虚函数表分析
12-22
C++虚函数表分析 C++中的虚函数是实现多态性的重要机制，它允许子类重写基类的方法，并在运行时动态决定调用哪个版本的函数。虚函数表（Virtual Function Table，简称vtable）是C++编译器为了实现这种动态绑定而...
虚函数,虚继承与虚函数表
_tree_
04-29 371
c++实现多态机制 ： 模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议 １］虚函数＝＝〉带有ｖｉｒｔｕｅ关键字的函数，并且不带有＝０标志的 ２］虚继承带有ｖｉｒｔｕａｌ关键字的继承，基类被称为虚基类，会在自己对象的实例中产生虚基类指针 虚函数与菱形继承的问题： １］ 当发生继承时，如果派生类重写了基类的虚函数，那么派生类的对象中会修改
C++虚函数和虚继承浅析
weixin_30821731的博客
03-12 124
本文针对C++里的虚函数，虚继承表现和原理进行一些简单分析，有不对的地方请指出。下面都是以VC2008编译器对这两种机制内部实现为例。 虚函数 　　一下是百度百科对于虚函数的解释： 定义：在某基类中声明为 virtual 并在一个或多个派生类中被重新定 义的成员函数[1]​ 语法：virtual 函数返回类型 函数名（参数表） {函数体} 用途：实现多态性，通过指向派生类的基类指...
虚函数与虚继承
yile0000的博客
04-01 735
封装、继承、多态是面向对象语言的三大特性，熟悉C++的人对此应该不会有太多异议。C语言提供的struct，顶多算得上对数据的简单封装，而C++的引入把struct“升级”为class，使得面向对象的概念更加强大。继承机制解决了对象复用的问题，然而多重继承又会产生成员冲突的问题，虚继承在我看来更像是一种“不得已”的解决方案。多态让对象具有了运行时特性，并且它是软件设计复用的本质，虚函数的出现为多态性
虚函数、虚函数表、虚继承
The Coding World
04-10 3169
1、虚函数 虚函数的定义：       虚函数必须是类的非静态成员函数(且非构造函数)，其访问权限是public（可以定义为privateor proteceted, 但是对于多态来说，没有意义），在基类的类定义中定义虚函数的一般形式： virtual 函数返回值类型虚函数名（形参表） { 函数体 } 定义虚函数的限制： （1）非类的成员函数不能定义为虚函数
关于虚函数、虚继承和虚表
Hao先森的专栏
07-13 930
一、虚函数         首先，虚函数的定义为在函数前添加关键字virtual。然后，之所以定义虚函数，是为了实现语言的多态性的特点。         虚函数里面有纯虚函数的玩意。通过直接在虚函数后面添加= 0来实现，举例如下：         virtual void (*Fun)() = 0;         应该注意的是，当一个类中出现了至少一个纯虚函数时，这个类就成为了传说中的抽
c++虚函数表问题(总结)+虚继承问题
苏州-青蛙
05-12 943
c++实现多态的虚表和对象模型 是初级中级必须要知道的问题,每次我需要知道都会看一遍，有的时候也忘记。我索性做个总结，之后就希望忘了就在这里找，不看这块内容了。 参考博客：https://blog.csdn.net/songguangfan/article/details/87898915 一个类对象的内存布局成员的影响因素： 1）成员变量 2）虚函数（产生虚函数表） 3）单一继承...
虚函数 虚继承
shandianling
09-17 728
#include using namespace std; class A { virtual void aa() { } }; class B: public A { public: virtual void bb() { } }; class C: public B { public: virtual void cc() { } }; int main() { cout
虚函数，虚继承
qq_43440004的博客
01-04 169
多态时实现了接口复用 c++中实现多态有两种，一种是静多态，另一种是动多态 静多态通过重载完成 静多态又叫静态绑定或早绑定，在编译期间确定函数入口地址 动多态通过虚函数完成 动多态又称动态绑定或晚邦定（在运行时动态确定函数入口地址，call的是寄存器） 虚函数关键字virtual 在基类中定义一个虚函数会产生一个虚函数指针，指向一个虚表（虚表在编译期间生成）只有数据段和指令段才能加载到内存，把虚表...
虚函数和虚继承
fzzjoy的专栏
10-03 216
虚函数表指针：vfptr -> 指向一个虚函数表。 虚基类指针：vbptr -> 指向一个虚基类表。 带虚函数的多重继承的内存布局 #include <iostream> using namespace std; class Base1 { public: //三个虚函数 virtual void f() { cout << "Base1::f" << endl; } virtual void g() { cout << .
虚函数&虚继承
FLYtcf的博客
09-26 356
多继承和虚继承多重继承虚继承，解决二义性，节省内存占用 多重继承 虚继承，解决二义性，节省内存占用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值