c++ 虚函数内存布局示意图

最新推荐文章于 2023-02-03 22:24:04 发布
最新推荐文章于 2023-02-03 22:24:04 发布
阅读量1k 收藏 12
点赞数 1
分类专栏： c++ 文章标签： c++ 多态 虚函数 内存 虚函数表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenwh_cn/article/details/116458435
版权

文章目录

一、virtual 虚函数工作原理

C++规定了虚函数的行为，但将实现方法留给了编译器
通常编译器处理虚函数的方法是： 给每个对象添加一个隐藏成员 __vfptr，是一个指向函数数组（虚函数表 vftable）的指针，虚函数表中存储的就是虚函数地址

二、虚函数内存布局

1.基类和派生类同名函数，不能被继承

#include <iostream>
using namespace std;

class Base {
public:
    void func1() {
        cout << "Base::func1" << endl;
    }

    int b;
};

class Derive : public Base {
public:
    void func1(int i) {
        cout << "Derive::func1" << endl;
    }

    int d;
};

int main() {
    Base bObj;
    Derive dObj;

    cout << sizeof(Base) << " " << sizeof(Derive) << endl; // 4 8

    bObj.func1();    // Base::func1
    // dObj.func1(); // error C2660: 'Derive::func1': function does not take 0 arguments
    dObj.func1(5);   // Derive::func1

    return 0;
}

运行结果如下：
当基类和派生类中函数同名但参数不同时，基类函数不能被派生类继承，派生类中并不构成重载

2.单继承，无虚函数覆盖，无新增虚函数

#include <iostream>
using namespace std;

class Base {
public:
    virtual void func1() {
        cout << "Base::func1" << endl;
    }

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

    int b;
};

class Derive : public Base {
public:
    int d;
};

int main() {
    Base bObj;
    bObj.b = 1;

    Derive dObj;
    dObj.b = 2;
    dObj.d = 3;

    cout << sizeof(Base) << " " << sizeof(Derive) << endl; // 8 12

    return 0;
}

在这里插入图片描述

i.基类的内存布局：

基类对象在内存中占用 8 个字节，一个是虚函数表指针 __vfptr，一个是成员变量 b
虚函数表占用 8 个字节，包括两个虚函数地址，虚函数表大小不计算在对象内
对象后面的 cccccccc 是为了分隔该对象和其它内容，虚函数表最后的四个字节均为0，表示虚表已经结束，不同系统不一样
在这里插入图片描述

ii.派生类的内存布局：

派生类对象在内存中占用 12 个字节，一个是虚函数表指针 __vfptr，一个是继承的成员变量 b，另一个是自己的成员变量 d
虚函数表占用 8 个字节，包括两个虚函数地址，与基类虚函数表中的函数地址一致，但和基类是两个独立的虚函数表
在这里插入图片描述

3.单继承，有虚函数覆盖，无新增虚函数

#include <iostream>
using namespace std;

class Base {
public:
    virtual void func1() {
        cout << "Base::func1" << endl;
    }

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

    int b;
};

class Derive : public Base {
public:
    void func1() {
        cout << "Derive::func1" << endl;
    }

    int d;
};

int main() {
    Base bObj;
    bObj.b = 1;

    Derive dObj;
    dObj.b = 2;
    dObj.d = 3;

    cout << sizeof(Base) << " " << sizeof(Derive) << endl; // 8 12

    bObj.func1(); // Base::func1
    bObj.func2(); // Base::func2
    dObj.func1(); // Derive::func1
    dObj.func2(); // Base::func2

    return 0;
}

在这里插入图片描述在这里插入图片描述运行结果如下：

  1. 派生类重写的虚函数覆盖了虚函数表中基类的虚函数
  2. 派生类没有重写的虚函数仍然继承虚函数表中基类的虚函数

4.单继承，有虚函数覆盖，有新增虚函数

#include <iostream>
using namespace std;

class Base {
public:
    virtual void func1() {
        cout << "Base::func1" << endl;
    }

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

    int b;
};

class Derive : public Base {
public:
    void func1() {
        cout << "Derive::func1" << endl;
    }
    
    virtual void func3() {
        cout << "Derive::func3" << endl;
    }
    
    int d;
};

int main() {
    Base bObj;
    bObj.b = 1;

    Derive dObj;
    dObj.b = 2;
    dObj.d = 3;

    cout << sizeof(Base) << " " << sizeof(Derive) << endl; // 8 12

    bObj.func1(); // Base::func1
    bObj.func2(); // Base::func2
    dObj.func1(); // Derive::func1
    dObj.func2(); // Base::func2
    dObj.func3(); // Derive::func3

    return 0;
}

在这里插入图片描述
运行结果如下：

  1. 派生类重写的虚函数覆盖了虚函数表中基类的虚函数
  2. 派生类没有重写的虚函数仍然继承虚函数表中基类的虚函数
  3. 派生类新增的虚函数添加到虚函数表的末尾

5.多继承，没有虚函数覆盖，没有新增虚函数

#include <iostream>
using namespace std;

class Base1 {
public:
    virtual void func1() {
        cout << "Base1::func1" << endl;
    }

    virtual void func2() {
        cout << "Base1::func2" << endl;
    }

    int b1;
};

class Base2 {
public:
    virtual void func3() {
        cout << "Base2::func3" << endl;
    }

    virtual void func4() {
        cout << "Base2::func4" << endl;
    }

    int b2;
};

class Derive : public Base1, public Base2 {
public:
    int d;
};

int main() {
    Base1 b1Obj;
    Base2 b2Obj;
    Derive dObj;

    b1Obj.b1 = 1;
    b2Obj.b2 = 2;
    dObj.b1 = 3;
    dObj.b2 = 4;
    dObj.d = 5;

    cout << sizeof(Base1) << " " << sizeof(Base2) << " " << sizeof(Derive) << endl; // 8 8 20

    b1Obj.func1(); // Base1::func1
    b1Obj.func2(); // Base1::func2
    b2Obj.func3(); // Base2::func3
    b2Obj.func4(); // Base2::func4
    dObj.func1();  // Base1::func1
    dObj.func2();  // Base1::func2
    dObj.func3();  // Base2::func3
    dObj.func4();  // Base2::func4

    return 0;
}

在这里插入图片描述在这里插入图片描述在这里插入图片描述
运行结果如下：

  1. 派生类拥有多个虚函数表，个数与拥有虚函数的基类个数相同
  2. 每个虚函数表中的函数地址均与基类的虚函数地址一致

6.多继承，有虚函数覆盖，没有新增虚函数

#include <iostream>
using namespace std;

class Base1 {
public:
    virtual void func1() {
        cout << "Base1::func1" << endl;
    }

    virtual void func2() {
        cout << "Base1::func2" << endl;
    }

    int b1;
};

class Base2 {
public:
    virtual void func1() {
        cout << "Base2::func1" << endl;
    }

    virtual void func2() {
        cout << "Base2::func2" << endl;
    }

    virtual void func3() {
        cout << "Base2::func3" << endl;
    }

    virtual void func4() {
        cout << "Base2::func4" << endl;
    }

    int b2;
};

class Derive : public Base1, public Base2 {
public:
    void func1() {
        cout << "Derive::func1" << endl;
    }

    void func3() {
        cout << "Derive::func3" << endl;
    }

    int d;
};

int main() {
    Base1 b1Obj;
    Base2 b2Obj;
    Derive dObj;

    b1Obj.b1 = 1;
    b2Obj.b2 = 2;
    dObj.b1 = 3;
    dObj.b2 = 4;
    dObj.d = 5;

    cout << sizeof(Base1) << " " << sizeof(Base2) << " " << sizeof(Derive) << endl; // 8 8 20

    b1Obj.func1(); // Base1::func1
    b1Obj.func2(); // Base1::func2
    b2Obj.func1(); // Base2::func1
    b2Obj.func2(); // Base2::func2
    b2Obj.func3(); // Base2::func3
    b2Obj.func4(); // Base2::func4
    dObj.func1();  // Derive::func1
    dObj.Base1::func1(); // Base1::func1
    dObj.Base2::func1(); // Base2::func1
    // dObj.func2();  // error C2385: ambiguous access of 'func2'
    dObj.Base1::func2(); // Base1::func2
    dObj.Base2::func2(); // Base2::func2
    dObj.func3();  // Derive::func3
    dObj.func4();  // Base2::func4

    return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
运行结果如下：

  1. 派生类拥有多个虚函数表，个数与拥有虚函数的基类个数相同
  2. 派生类重写的虚函数覆盖了所有虚函数表中基类的虚函数
  3. 派生类没有重写的虚函数仍然继承虚函数表中基类的虚函数

7.多继承，有虚函数覆盖，有新增虚函数

#include <iostream>
using namespace std;

class Base1 {
public:
    virtual void func1() {
        cout << "Base1::func1" << endl;
    }

    virtual void func2() {
        cout << "Base1::func2" << endl;
    }

    int b1;
};

class Base2 {
public:
    virtual void func1() {
        cout << "Base2::func1" << endl;
    }

    virtual void func3() {
        cout << "Base2::func3" << endl;
    }

    int b2;
};

class Derive : public Base1, public Base2 {
public:
    void func1() {
        cout << "Derive::func1" << endl;
    }

    virtual void func4() {
        cout << "Derive::func4" << endl;
    }
    int d;
};

int main() {
    Base1 b1Obj;
    Base2 b2Obj;
    Derive dObj;

    b1Obj.b1 = 1;
    b2Obj.b2 = 2;
    dObj.b1 = 3;
    dObj.b2 = 4;
    dObj.d = 5;

    cout << sizeof(Base1) << " " << sizeof(Base2) << " " << sizeof(Derive) << endl; // 8 8 20
    
    b1Obj.func1();   // Base1::func1
    b1Obj.func2();   // Base1::func2
    b2Obj.func1();   // Base2::func1
    b2Obj.func3();   // Base2::func3
    dObj.func1();    // Derive::func1
    dObj.func2();    // Base1::func2
    dObj.func3();    // Base2::func3
    dObj.func4();    // Derive::func4

    return 0;
}

在这里插入图片描述
在这里插入图片描述
运行结果如下：

  1. 派生类拥有多个虚函数表，个数与拥有虚函数的基类个数相同
  2. 派生类重写的虚函数覆盖了所有虚函数表中基类的虚函数
  3. 派生类没有重写的虚函数仍然继承虚函数表中基类的虚函数
  4. 派生类新增的虚函数存放在继承的第一个基类的虚函数表中，并且添加到表的末尾

三、虚函数表指针访问

1.代码示例

#include <iostream>
using namespace std;

class Base1 {
public:
    virtual void func1() {
        cout << "Base1::func1" << endl;
    }

    virtual void func2() {
        cout << "Base1::func2" << endl;
    }

    int b1;
};

class Base2 {
public:
    virtual void func1() {
        cout << "Base2::func1" << endl;
    }

    virtual void func3() {
        cout << "Base2::func3" << endl;
    }

    int b2;
};

class Derive : public Base1, public Base2 {
public:
    void func1() {
        cout << "Derive::func1" << endl;
    }

    virtual void func4() {
        cout << "Derive::func4" << endl;
    }
    int d;
};

int main() {
    Base1 b1Obj;
    Base2 b2Obj;
    Derive dObj;

    b1Obj.b1 = 1;
    b2Obj.b2 = 2;
    dObj.b1 = 3;
    dObj.b2 = 4;
    dObj.d = 5;

    typedef void(*Func) (void);
    int ** vftable = (int **)&dObj;

    cout << "[0]Base1::__vfptr" << endl;
    cout << "    [0] "; ((Func)vftable[0][0])();
    cout << "    [1] "; ((Func)vftable[0][1])();
    cout << "    [2] "; ((Func)vftable[0][2])();

    cout << "[1]Base1::b1" << endl;
    cout << "    [0] b1 = " << vftable[1] << endl;

    cout << "[2]Base2::__vfptr" << endl;
    cout << "    [0] "; ((Func)vftable[2][0])();
    cout << "    [1] "; ((Func)vftable[2][1])();

    cout << "[3]Base2::b2" << endl;
    cout << "    [0] b2 = " << vftable[3] << endl;

    cout << "[4]Derive::d" << endl;
    cout << "    [0] d = " << vftable[4] << endl;

    cout << "[5]End" << endl;
    cout << "    " << hex << vftable[5] << endl;

    return 0;
}

/* output:
[0]Base1::__vfptr
	[0] Derive::func1
	[1] Base1::func2
	[2] Derive::func4
[1]Base1::b1
	[0] b1 = 00000003
[2]Base2::__vfptr
	[0] Derive::func1
	[1] Base2::func3
[3]Base2::b2
	[0] b2 = 00000004
[4]Derive::d
	[0] d = 00000005
[5]End
	CCCCCCCC		
*/

在这里插入图片描述

2.安全性

i. 通过基类指针访问派生类新增的虚函数

在上面的结果中可以看到 Base1::__vfptr 虚函数表中有派生类新增的虚函数，但我们不能通过基类指针来访问派生类新增的虚函数：

Base1 *b1 = new Derive();
b1->func4();  // 编译出错

妄图使用基类指针调用派生类中新增虚函数的行为都会被编译器视为非法，无法编译通过
但在运行时，由上面例子可见，可以访问虚函数表通过指针偏移的方式来实现，不过这样违反了C++的语义

ii. 访问 non-public 的虚函数

如果基类的虚函数是 private 或 protected 的，虚函数同样会存在于虚函数表中，同样可以访问虚函数表通过指针偏移的方式来实现，不过这样也违反了C++的语义

#include <iostream>
using namespace std;

class Base {
public:
    virtual void func1() {
        cout << "Base1::func1" << endl;
    }
};

class Derive : public Base {

};

int main() {
    typedef void(*Func) (void);
    
    Derive dObj;
	int ** vftable = (int **)&dObj;
	((Func)vftable[0][0])(); // Base::func1

    return 0;
}
千年缘
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++知识积累：继承关系（含虚函数）下类的内存布局
HerofH_的博客
06-22 1495
目录 1 无继承 2 一般继承 2.1 单继承 2.2 多层继承 2.3 多重继承 2.4菱形继承 3 虚继承 3.1 虚继承的布局 3.2 虚继承的多层继承 3.3 虚继承的菱形继承 总结 1 无继承 类A定义如下： class A { private: int A_1; public: static int A_2; int A_3; ...
C++对象的内存布局
03-03
前言07年12月，我写了一篇《C++虚函数表解析》的文章，引起了大家的兴趣。有很多朋友对我的文章留了言，有鼓励我的，有批评我的，还有很多问问题的。我在这里一并对大家的留言表示感谢。这也是我为什么再写一篇续言的原因。因为，在上一篇文章中，我用了的示例都是非常简单的，主要是为了说明一些机理上的问题，也是为了图一些表达上方便和简单。不想，这篇文章成为了打开C++对象模型内存布局的一个引子，引发了大家对C++对象的更深层次的讨论。当然，我之前的文章还有很多方面没有涉及，从我个人感觉下来，在谈论虚函数表里，至少有以下这些内容没有涉及：1）有成员变量的情况。2）有重复继承的情况。3）有虚拟继承的情况。4）
CPP.rar_C++虚函数
09-24
有关成员函数，有关派生类，有关虚函数的C++课程设计
C++虚函数实现原理
10-24
虚函数表中虚函数的分布情况；其中包括发生继承的情况下虚函数表中虚函数的分布情况；
浅析C++中的虚函数
12-26
一、定义定义：在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数。 语法：virtual 函数返回类型函数名（参数表） { 函数体 } 　　 用途：实现多态性，通过指向派生类的基类指针，访问派生类中同名覆盖成员函数　　虚函数必须是基类的非静态成员函数，其访问权限可以是protected或public。 定义为virtual的函数是基类期待派生类重新定义的，基类希望派生类继承的函数不能定义为虚函数。 二、作用虚函数的作用是实现动态联编，也就是在程序的运行阶段动态地选择合适的成员函数，在定义了虚函数后，可以在基类的派生类中对虚函数重新定义，在派生类中重新定义的函数应与虚
C++ | 虚函数表内存布局
专注于C/C++/Linux领域创作
02-19 2007
虚表指针 虚函数有个特点。存在虚函数的类会在类的数据成员中生成一个虚函数指针 vfptr，而vfptr 指向了一张表（简称，虚表）。正是由于虚函数的这个特性，C++的多态才有了发生的可能。 其中虚函数表由三部分组成，分别是 RTTI（运行时类型信息）、偏移及虚函数的入口地址。而虚表与类及类生成的对象有存在着以下两种关系： 类与虚表的关系：一个类只有一个虚表 对象与类的关系：所有对象共享一个虚表 ...
【C++】虚函数及其内存布局
Jacky_Feng的博客
10-18 1743
一、函数调用捆绑 把函数体与函数调用相联系称为捆绑。 当捆绑在程序运行之前（由编译器和连接器）完成时，称为早捆绑。C编译只有一种函数调用方式，就是早捆绑。 早捆绑引起的问题：因为编译器在只有对象的地址时它并不知道要调用的正确函数。 根据对象的类型，捆绑发生在运行时，这种捆绑方式称为晚捆绑，又称动态捆绑。 二、虚函数 对于特定的函数，为了引起晚捆绑，C++要求在基类中声明这个函数时使用virtual关键字，这样的函数称为虚函数。晚捆绑只对virtual函数起作用，而且只在使用含有virtual函.
虚函数的复杂（继承）内存布局
Codenange的博客
02-03 687
继承关系一般分为：单继承和多继承，而多继承的出现就又导致了一种特殊的继承关系菱形继承，为了解决菱形继承的冗余和二义性，又有了菱形虚拟继承的解决方案。本篇主要介绍以上四种继承关系的类对象虚函数内存布局。
C++ 对象内存模型
一只老风铃
09-12 1504
继承，封装，多态是面向对象的三大特性之一，以类为例，类分为数据成员和函数 而函数分为static、非static、virtual函数三大类函数，那么一般的C++对象其内存模型是如何。 类中存在部分： 成员变量 静态成员变量 成员函数 静态成员函数 构造函数 析构函数 虚函数 虚析构函数 纯虚函数 通常而言对于一个对象，其在内存中的模型不包含函数，只包含成员，而函数单独存放，所有对象通过地址进行调用。对象在内存模型及其占用大小受几方面因素影响： 成员变量 虚表指针 虚基类表指.
C++ 虚函数的对象模型
chengonghao的博客
06-18 1993
1.无继承的普通类：    在有虚函数的情况下类会为其增加一个隐藏的成员，虚函数表指针，指向一个虚函数表，虚函数表里面就是类的各个虚函数的地址了。那么，虚函数表指针是以什么模型加入到类里面的，虚函数表里面又是怎么安排的呢。简单来看下就可以知道了。 #include"stdafx.h" #pragma pack(8) class A{ public: int a
c++ 类 虚函数列表及其内存分布
04-28
c++ 类 虚函数列表及其内存分布
详解C++编程中的虚函数
09-03
主要介绍了详解C++编程中的虚函数,包括在什么情况下应当声明虚函数的相关讲解,需要的朋友可以参考下
C++虚函数及虚函数表解析
07-24
C++虚函数及虚函数表解析，内容详细，分析清晰，推荐给大家。
C++虚函数及虚函数表简析
09-03
主要介绍了C++虚函数及虚函数表，内容非常详细，思路清晰,需要的朋友可以参考下
C++虚函数的实现机制分析
01-01
本文针对C++的虚函数的实现机制进行较为深入的分析，具体如下： 1、简单地说，虚函数是通过虚函数表实现的。那么，什么是虚函数表呢？ 事实上，如果一个类中含有虚函数，则系统会为这个类分配一个指针成员指向一张虚函数表（vtbl），表中每一项指向一个虚函数的地址，实现上就是一个函数指针的数组。 例如下面这个例子： class Parent { public: virtual void foo1() { } virtual void foo1() { } void foo1(); }; class Child1 { public: void foo1() { } void foo3();
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型...
C++ 虚函数的详解及简单实例
01-01
C++ 虚函数的详解 虚函数的使用和纯虚函数的使用。 虚函数是在基类定义，然后子类重写这个函数后，基类的指针指向子类的对象，可以调用这个函数，这个函数同时保留这子类重写的功能。 纯虚函数是可以不用在基类定义...
C++ 内存对象布局
11-08
涉及各种情况下C++对象的sizeof大小，包括单一类对象，继承，重复继承 多继承 单一虚继承 等各种情况下的对象大小。对C++对象内存布局有清楚了解。
C++虚函数表实例分析
01-21
在对象中，有一个指针指向一张虚函数表，里面按照次序存放了每一个虚函数，当子类继承的时候，即到虚函数表的指定位置去修改函数地址。当我们通过父类指针来操作一个子类的时候，调用虚函数，都是通过虚函数表+固定...
c++ 虚函数指针和虚函数表
最新发布
08-23
虚函数指针和虚函数表是C++中实现多态性的关键概念。在C++中，如果一个类中包含至少一个虚函数，那么这个类就被称为多态类。每个多态类都有一个虚函数表，表中存储了该类的虚函数的地址。 虚函数指针是一个特殊的指针，用来指向虚函数表。在多态类中，每个对象都有一个隐藏的虚函数指针，指向它所属的类的虚函数表。当通过基类指针或引用调用虚函数时，程序会根据虚函数指针找到相应的虚函数表，并调用正确的虚函数。 通过使用虚函数指针和虚函数表，C++实现了运行时多态性，即在程序运行时确定调用的具体函数。这使得我们可以通过基类指针或引用来操作派生类对象，而不需要知道对象的具体类型。 需要注意的是，虚函数表是每个类独有的，而虚函数指针是每个对象独有的。在继承关系中，派生类会继承基类的虚函数表，并在其中添加自己的虚函数。这样就实现了派生类对象可以通过基类指针或引用调用自己的虚函数和继承自基类的虚函数的功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值