c++虚函数表中的内存布局

已于 2024-04-21 01:07:33 修改
阅读量502 收藏 8
点赞数 6
分类专栏： c/c++知识二次稳固 文章标签： c++ 开发语言
于 2024-04-07 10:13:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_52668597/article/details/137447982
版权

c++虚函数表中的内存布局

1.Class的内存分布

#include <iostream>

using namespace std;

#define Debug  cout<<'<'<<__FILE__<<">,"<<__FUNCTION__<<","<<__LINE__<<endl

class Base
{

};

int main()
{
    cout<<sizeof(Base)<<endl;//1

    return 0;
}

#include <iostream>

using namespace std;

#define Debug  cout<<'<'<<__FILE__<<">,"<<__FUNCTION__<<","<<__LINE__<<endl

class Base
{
private:
    int _val;
    int static _staticval;//说明静态成员变量不属于类

public:
    int Getval() const//说明成员函数也不属于类
    {
        return _val;
    }
};

int main()
{
    cout<<sizeof(Base)<<endl;//4

    return 0;
}

#include <iostream>

using namespace std;

#define Debug cout << '<' << __FILE__ << ">," << __FUNCTION__ << "," << __LINE__ << endl

class Base
{
private:
    int _val;
    int static _staticval; // 说明静态成员变量不属于类

public:
    int Getval() const // 说明成员函数也不属于类
    {
        return _val;
    }
};

class Base_A : public Base
{
};

int main()
{
    cout << sizeof(Base_A) << endl; // 4
    printf("%p\n%p\n", &Base::Getval, &Base_A::Getval);
    /*
    00007FF6D2AC1131
    00007FF6D2AC1131   //不重载的话,从派生类继承下来的函数是同一个函数,也就是说"函数的内存不在类里面"
    */

    return 0;
}

#include <iostream>

using namespace std;

#define Debug  cout<<'<'<<__FILE__<<">,"<<__FUNCTION__<<","<<__LINE__<<endl

class Base
{
private:
    int _val;
    int static _staticval;//说明静态成员变量不属于类

public:
    int Getval() const//说明成员函数也不属于类
    {
        return _val;
    }
};

class Base_A : public Base
{
public:
    int Getval() const
    {
        return 0;
    }
};

int main()
{
    cout<<sizeof(Base_A)<<endl;//4
    printf("%p\n%p\n",&Base::Getval,&Base_A::Getval);
    /*
    000000000061fdf0
    000000000061fde0   //重载了所以地址才发生了变化
    */

    return 0;
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2.其他修改Class中变量的方法

在这里插入图片描述
类这种概念只在编译的时候存在

#include <iostream>

using namespace std;

#define Debug cout << '<' << __FILE__ << ">," << __FUNCTION__ << "," << __LINE__ << endl

class Base
{
private:
    int _val;
    int _valB;
public:
    int GetVal() const
    {
        return _val;
    }
    int GetValB() const
    {
        return _valB;
    }
};



int main()
{
    Base obj;
    int* objPtr = (int*)&obj;
    *objPtr = 999;

    *(objPtr + 1) = 1000;

    cout << obj.GetVal() << endl;//999
    cout << obj.GetValB() << endl;//1000
    

    return 0;
}

#include <iostream>

using namespace std;

#define Debug cout << '<' << __FILE__ << ">," << __FUNCTION__ << "," << __LINE__ << endl

class Base
{

public:
    virtual void VirA()
    {
        Debug;
    }
    virtual void VirB()
    {
        Debug;
    }
    virtual void VirC()
    {
        Debug;
    }
};

using U8 = long long;
using FuncPtr = void(*)();//函数指针
int main()
{
    Base obj;
    U8* objAddre = (U8*)&obj;//这个类
    U8* objArr = (U8*)(*objAddre);//解引用,这时候,就是那个虚函数的数组

    ((FuncPtr)objArr[0]) ();
    ((FuncPtr)objArr[1]) ();
    ((FuncPtr)objArr[2]) ();

    /*输出
    <D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirA,13
    <D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirB,17
    <D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirC,21
    */

    return 0;
}

3.通过虚函数表内存偏移调用虚函数

#include <iostream>

using namespace std;

#define Debug cout << '<' << __FILE__ << ">," << __FUNCTION__ << "," << __LINE__ << endl

class Base
{

public:
    virtual void VirA()
    {
        Debug;
    }
    virtual void VirB()
    {
        Debug;
    }
    virtual void VirC()
    {
        Debug;
    }
};

using U8 = long long;
using FuncPtr = void(*)();//函数指针
int main()
{
    Base obj;
    U8* objAddre = (U8*)&obj;//这个类
    U8* objArr = (U8*)(*objAddre);//解引用,这时候,就是那个虚函数的数组

    ((FuncPtr)objArr[0]) ();
    ((FuncPtr)objArr[1]) ();
    ((FuncPtr)objArr[2]) ();

    /*输出
    <D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirA,13
    <D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirB,17
    <D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirC,21
    */

    return 0;
}

#include <iostream>

using namespace std;

#define Debug cout << '<' << __FILE__ << ">," << __FUNCTION__ << "," << __LINE__ << endl

class Base
{

public:
    virtual void VirA()
    {
        Debug;
    }
    virtual void VirB()
    {
        Debug;
    }
    virtual void VirC()
    {
        Debug;
    }
};

using U8 = long long;
using FuncPtr = void(*)();//函数指针
int main()
{
    {
        Base obj;
        U8* objAddre = (U8*)&obj;//这个类
        U8* objArr = (U8*)(*objAddre);//解引用,这时候,就是那个虚函数的数组
        printf("%p\n", objArr);
        ((FuncPtr)objArr[0]) ();
        ((FuncPtr)objArr[1]) ();
        ((FuncPtr)objArr[2]) ();
    }
    {
        Base obj;
        U8* objAddre = (U8*)&obj;//这个类
        U8* objArr = (U8*)(*objAddre);//解引用,这时候,就是那个虚函数的数组

        printf("%p\n",objArr);
    }

    /*输出
    00007FF63F7BBD30
    <D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirA,13
    <D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirB,17
    <D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirC,21
    00007FF63F7BBD30///地址一样:说明:同一个类 实例化多个对象 虚函数表指针是一样的
    */

    return 0;
}

在这里插入图片描述

4.继承状态下的虚函数表内存

  • 1.没有重写,虚函数表中的元素地址是一样的
  • 2.重写后,对应的虚函数表中的函数指针就是新的地址
#include <iostream>

using namespace std;

#define Debug cout << '<' << __FILE__ << ">," << __FUNCTION__ << "," << __LINE__ << endl

class Base
{

public:
    virtual void VirA()
    {
        Debug;
    }
    virtual void VirB()
    {
        Debug;
    }
    virtual void VirC()
    {
        Debug;
    }
};

class A_Base : public Base
{
    virtual void VirB()
    {
        Debug;
    }
};

using U8 = long long;
using FuncPtr = void(*)();//函数指针
int main()
{
    {
        A_Base obj;
        U8* objAddre = (U8*)&obj;//这个类
        U8* objArr = (U8*)(*objAddre);//解引用,这时候,就是那个虚函数的数组
        //printf("%p\n", objArr);
        ((FuncPtr)objArr[0]) ();
        ((FuncPtr)objArr[1]) ();
        ((FuncPtr)objArr[2]) ();
    }
 

    /*输出
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirA,13
<D:\vs2022\code\测试cpp语法\main.cpp>,A_Base::VirB,29
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirC,21
    */

    return 0;
}

在这里插入图片描述

#include <iostream>

using namespace std;

#define Debug cout << '<' << __FILE__ << ">," << __FUNCTION__ << "," << __LINE__ << endl

class Base
{

public:
    virtual void VirA()
    {
        Debug;
    }
    virtual void VirB()
    {
        Debug;
    }
    virtual void VirC()
    {
        Debug;
    }
};

class A_Base : public Base
{
    virtual void VirB()
    {
        Debug;
    }
};

using U8 = long long;
using FuncPtr = void(*)();//函数指针
int main()
{
    {
        Base obj;
        U8* objAddre = (U8*)&obj;//这个类
        U8* objArr = (U8*)(*objAddre);//解引用,这时候,就是那个虚函数的数组
        //printf("%p\n", objArr);
        ((FuncPtr)objArr[0]) ();
        ((FuncPtr)objArr[1]) ();
        ((FuncPtr)objArr[2]) ();

        for(int i = 0 ; i < 3 ; i++)
            printf("%p\n", objArr[i]);
    }
    printf(".........................................................\n");
    {
        A_Base obj;
        U8* objAddre = (U8*)&obj;//这个类
        U8* objArr = (U8*)(*objAddre);//解引用,这时候,就是那个虚函数的数组
        //printf("%p\n", objArr);
        ((FuncPtr)objArr[0]) ();
        ((FuncPtr)objArr[1]) ();
        ((FuncPtr)objArr[2]) ();

        for (int i = 0; i < 3; i++)
            printf("%p\n", objArr[i]);
    }
 

    /*输出
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirA,13
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirB,17
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirC,21
00007FF7979B1442
00007FF7979B115E
00007FF7979B1474
.........................................................
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirA,13
<D:\vs2022\code\测试cpp语法\main.cpp>,A_Base::VirB,29
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirC,21
00007FF7979B1442
00007FF7979B14B0
00007FF7979B1474
    */

    return 0;
}

在这里插入图片描述

5.派生类函数中多出来的虚函数访问(“父类指针指向子类对象”)

“基类指针指向子类对象"或"基类指针指向派生类对象”

#include <iostream>

using namespace std;

#define Debug cout << '<' << __FILE__ << ">," << __FUNCTION__ << "," << __LINE__ << endl

class Base
{

public:
    virtual void VirA()
    {
        Debug;
    }
    virtual void VirB()
    {
        Debug;
    }
    virtual void VirC()
    {
        Debug;
    }
};

class A_Base : public Base
{
    virtual void VirB()
    {
        Debug;
    }

    virtual void VirD()
    {
        Debug;
    }
};

using U8 = long long;
using FuncPtr = void(*)();//函数指针
int main()
{
    {
        Base obj;
        U8* objAddre = (U8*)&obj;//这个类
        U8* objArr = (U8*)(*objAddre);//解引用,这时候,就是那个虚函数的数组
        //printf("%p\n", objArr);
        ((FuncPtr)objArr[0]) ();
        ((FuncPtr)objArr[1]) ();
        ((FuncPtr)objArr[2]) ();

        for (int i = 0; i < 3; i++)
            printf("%p\n", objArr[i]);
    }
    printf(".........................................................\n");
    {
        A_Base obj;
        U8* objAddre = (U8*)&obj;//这个类
        U8* objArr = (U8*)(*objAddre);//解引用,这时候,就是那个虚函数的数组
        //printf("%p\n", objArr);
        ((FuncPtr)objArr[0]) ();
        ((FuncPtr)objArr[1]) ();
        ((FuncPtr)objArr[2]) ();

        for (int i = 0; i < 3; i++)
            printf("%p\n", objArr[i]);
    }

    {
        Base* obj = new A_Base;
        //obj->VirD();//报错:常规的方法:基类指针 无法访问 派生类函数中多出来的虚函数
        U8* objAddre = (U8*)obj;//这个类
        U8* objArr = (U8*)(*objAddre);//解引用,这时候,就是那个虚函数的数组
        ((FuncPtr)objArr[3]) ();
    }


    /*输出
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirA,13
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirB,17
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirC,21
00007FF71EBE14CE
00007FF71EBE1181
00007FF71EBE150A
.........................................................
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirA,13
<D:\vs2022\code\测试cpp语法\main.cpp>,A_Base::VirB,29
<D:\vs2022\code\测试cpp语法\main.cpp>,Base::VirC,21
00007FF71EBE14CE
00007FF71EBE10A5
00007FF71EBE150A
<D:\vs2022\code\测试cpp语法\main.cpp>,A_Base::VirD,34
    */

    return 0;
}

在这里插入图片描述

在这里插入图片描述

虚表的内存布局（c++）
陈嘉怡的专栏
04-13 2918
点击这里查看下篇＞＞＞ 前言  转自：http://blog.youkuaiyun.com/haoel/article/details/3081328 07年12月，我写了一篇《C++虚函数表解析》的文章，引起了大家的兴趣。有很多朋友对我的文章留了言，有鼓励我的，有批评我的，还有很多问问题的。我在这里一并对大家的留言表示感谢。这也是我为什么再写一篇续言的原因。因为，在上一篇文章中，我用了的示例都是非
C++虚函数表指针在内存中的位置
qq_41317716的博客
06-21 808
C++虚函数表指针在内存中的位置
C++ 虚函数表、函数地址、内存布局解析
教兽之家
05-15 1682
前言   C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。     关于虚函数的使
C++编程——图解虚函数内存模型并通过代码找到函数
最新发布
MiauwYuki的博客
03-17 978
图解虚函数表的内存模型，并且一步步通过图解和代码找到虚函数并直接调用。
C++ 虚函数内存布局
痞子龙3D编程
03-12 2375
由sizeof()求带有虚函数的类的大小引发的思考，在查看相关资料的过程中看到了陈皓先生的一篇文章《C++ 虚函数表解析》(详情见http://blog.youkuaiyun.com/haoel)觉得讲的十分的好，只是看完之后仍对为什么要又为什么可以由父类的指针调用子类的对象的虚函数不解，如这种典型的描述：Derive d;//Derive 是Base的子类Base *b1 = &d;//这必须使用父
c++笔记 虚函数表内存布局
tempsitegoogle
05-06 215
测试了一下vs2008中虚函数表的内存布局，测试代码如下： class A { public: virtual int getA() const { return a;} private: int a; }; class B { public: virtual int getB(){return b;} private: int b; }; cla...
【C++】虚函数及其内存布局
Jacky_Feng的博客
10-18 2263
一、函数调用捆绑 把函数体与函数调用相联系称为捆绑。 当捆绑在程序运行之前（由编译器和连接器）完成时，称为早捆绑。C编译只有一种函数调用方式，就是早捆绑。 早捆绑引起的问题：因为编译器在只有对象的地址时它并不知道要调用的正确函数。 根据对象的类型，捆绑发生在运行时，这种捆绑方式称为晚捆绑，又称动态捆绑。 二、虚函数 对于特定的函数，为了引起晚捆绑，C++要求在基类中声明这个函数时使用virtual关键字，这样的函数称为虚函数。晚捆绑只对virtual函数起作用，而且只在使用含有virtual函.
虚函数在对象中的内存布局
Lostyears的专栏
03-08 612
典型地，C++通过虚函数实现多态性。多态性的定义：“无论发送消息的对象属于什么类，他们均发送具有相同形式的消息，对消息的处理方式可能随接受消息的对象而变。”具体地说，“在某个基类上建立起来的类的层次结构中，可以对任何一个派生类的对象中的同名成员函数进行调用，而被调用的成员变量所提供的处理可以随其所属的类而改变。”虚函数首先是一种成员函数，它可以在该类的派生类中被重新定义并被赋予另外一种处理功能。
C++虚函数表、地址详解（x86/x64）
yuemouren的博客
08-08 1299
本文在上述博文的基础上，补充了x64下的验证代码。虚函数大家都知道是基本用于实现多态的，当父指向子类对象的时候，如何确定调用的函数是父类里的还是子类里面的，这就要用到虚函数表。下面一点点表诉什么是虚函数表，和虚函数表的特点。如有说错的地方，欢迎指正：1.编译器会为每个创建一个虚函数表如有类中没有虚函数，那么这个虚函数表就不存在，而不是表中无数据。同时，有虚函数的类都会有自己的虚函数表，虚函数表会被一个类的所有对象所拥有。
理解C++虚函数表：内存布局与多态实现
虚函数表是实现C++多态的关键机制，它在类的内存布局中占有特殊位置，而UML作为一种强大的建模工具，能帮助我们更好地组织和表达面向对象设计的复杂性。通过理解这两者，开发者可以更有效地设计和维护可扩展、灵活的...
C++类对象中虚函数表指针、虚函数表、虚函数之间的关系以及在内存中的布局
qq_41687938的博客
09-26 1086
​目录 C++类的虚函数表和虚函数在内存中的位置 虚函数表和虚函数在内存中的位置说明 结论 原文C++类的虚函数表和虚函数在内存中的位置_JMW1407的博客-优快云博客 C++类的虚函数表和虚函数在内存中的位置 关系：虚函数表指针(保存在堆或栈)->虚函数表(常量区.rodata)->虚函数(代码段 .text) 虚函数表指针是虚函数表所在位置的地址。虚函数表指针属于对象实例。因而通过new 出来的对象的虚函数表指针位于堆，声名对象的虚函数表指针位于栈。 总结： 1...
C++ 虚函数表 vtable
qq_62381297的博客
06-11 956
本篇文章通过小实验来了解了解虚函数表，测试环境 ubuntu16 gcc 5.4.0。
C++虚函数表与对象布局
幸福村的人
04-19 2139
 [转载]2006-10-26 23:33 每个含有虚函数的类有一张虚函数表(vtbl)，表中每一项指向一个虚函数的地址，实现上是一个函数指针的数组。 虚函数表既有继承性又有多态性。每个派生类的vtbl继承了它各个基类的vt
虚函数内存布局
m0_51735068的博客
09-28 201
虚函数内存布局，探究其实现
C++多态虚函数表内存布局
书山有路勤为径
07-08 846
假设有一个基类ClassA，一个继承了该基类的派生类ClassB，并且基类中有虚函数，派生类实现了基类的虚函数。 我们在代码中运用多态这个特性时，通常以两种方式起手： (1) ClassA *a = new ClassB(); (2) ClassB b; ClassA *a = &b; 以上两种方式都是用基类指针去指向一个派生类实例，区别在于第1个用了new关键字而分配在堆上，第2个分配在栈上。请看上图，不同两种方式起手仅仅影响了派生类对象实例存在的位置。...
C++虚函数内存布局
richard_如风的专栏
11-11 1372
虚继承 在多重继承下，一个基类可以在派生层次中出现多次，在这种情况下，采用虚继承，通过虚继承指出他希望共享其虚基类的状态，无论该虚基类出现过多少次，只继承一个共享的基类对象。 虚继承的初始化： 通常每个类只初始化自己的成员，但是该策略应用于虚继承时就会导致多次初始化虚基类，采用方法：从最底层派生类的构造函数初始化虚基类，任何直接或间接继承虚基类的类一般必须为该虚基类提供自己的初始化式。 举
C++ | 虚函数表内存布局
专注于C/C++/Linux领域创作
02-19 2822
虚表指针 虚函数有个特点。存在虚函数的类会在类的数据成员中生成一个虚函数指针 vfptr，而vfptr 指向了一张表（简称，虚表）。正是由于虚函数的这个特性，C++的多态才有了发生的可能。 其中虚函数表由三部分组成，分别是 RTTI（运行时类型信息）、偏移及虚函数的入口地址。而虚表与类及类生成的对象有存在着以下两种关系： 类与虚表的关系：一个类只有一个虚表 对象与类的关系：所有对象共享一个虚表 ...
C++ 对象内存模型
一只老风铃
09-12 1614
继承，封装，多态是面向对象的三大特性之一，以类为例，类分为数据成员和函数 而函数分为static、非static、virtual函数三大类函数，那么一般的C++对象其内存模型是如何。 类中存在部分： 成员变量 静态成员变量 成员函数 静态成员函数 构造函数 析构函数 虚函数 虚析构函数 纯虚函数 通常而言对于一个对象，其在内存中的模型不包含函数，只包含成员，而函数单独存放，所有对象通过地址进行调用。对象在内存模型及其占用大小受几方面因素影响： 成员变量 虚表指针 虚基类表指.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

踏过山河，踏过海

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值