【C/C++】【对象模型】虚函数

其他 2020-07-23 17:48:31 阅读次数: 0

虚函数表指针位置分析

类：有虚函数，会产生一个虚函数表；

类对象：有一个指针，指针vptr会指向虚函数表的开始地址；

虚函数指针的位置

虚函数表位于整个对象模型的顶端；

// objModel.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;
class A
{
public:
    virtual void func() {};

public:
    int i;
};

int main()
{
    A a;
    cout << sizeof(a) << endl;

    char* p = reinterpret_cast<char*>(&a);
    char* q = reinterpret_cast<char*>(&a.i);

    if (p == q) //如果二者位置相同，说明i在对象的上面；虚函数表指针vptr在下面；
        cout << "yes" << endl;
    else
        cout << "no" << endl; 
    return 0;
}

继承关系作用下虚函数的手工调用

// objModel.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void func()
    {
        cout << "Base::void func()" << endl;
    }

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


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


class Derive :public Base
{
public:
    virtual void gunc()
    {
        cout << "Derive::void hunc()" << endl;
    }
};

int main()
{
    //直接用类名和用对象一样，都是这个类的对象的大小
    cout << sizeof(Base) << endl; //父类 4字节
    cout << sizeof(Derive) << endl; //子类 4字节
    
    
    Derive* d = new Derive(); //派生类指针
    long* pvptr = (long*)d; //指向对象的指针d转成了long*类型
    long* vptr = (long*)(*pvptr); //(*pvptr)表示pvptr所指向的对象，也就是Derive本身， Derive对象是4字节，代表的是虚函数表指针



    for (int i = 0; i <= 2; i++) //循环3次 打印虚函数的入口地址
    {
        printf("vptr[%d] = 0x:%p\n", i, vptr[i]);
    }
    
    typedef void(*Func)(void); //定义一个函数指针类型
    Func f = (Func)vptr[0]; //f是函数指针变量，vptr[0]是指向第一个虚函数；
    Func g = (Func)vptr[1]; //f是函数指针变量，vptr[1]是指向第二个虚函数；
    Func h = (Func)vptr[2]; //f是函数指针变量，vptr[2]是指向第三个虚函数；
    
    f();
    g();
    h();


    cout << "---------------------------------------------------------------------" << endl;


    Base* b = new Base(); //基类指针
    long* pvptr_base = (long*)b; //指向对象的指针b转成了long*类型
    long* vptr_base = (long*)(*pvptr_base);

    for (int i = 0; i <= 2; i++) //循环3次 打印虚函数的入口地址
    {
        printf("Base[%d] = 0x:%p\n", i, vptr_base[i]);
    }
    Func f_base = (Func)vptr_base[0]; //f_base是函数指针变量，vptr_base[0]是指向第一个虚函数；
    Func g_base = (Func)vptr_base[1]; //g_base是函数指针变量，vptr_base[1]是指向第二个虚函数；
    Func h_base = (Func)vptr_base[2]; //h_base是函数指针变量，vptr_base[2]是指向第三个虚函数；
    f_base();
    g_base();
    h_base();

    return 0;
}

虚函数表分析

  • 一个类只有包含虚函数才存在虚函数表，同属于一个类的对象共享虚函数表，但是有各自的vptr（虚函数指针），所指向的虚函数的入口地址都是相同的；

    // objModel.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void func()
    {
        cout << "Base::void func()" << endl;
    }

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


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


class Derive :public Base
{
public:
    virtual void gunc()
    {
        cout << "Derive::void hunc()" << endl;
    }
};

int main()
{
    //直接用类名和用对象一样，都是这个类的对象的大小
    cout << sizeof(Base) << endl; //父类 4字节
    cout << sizeof(Derive) << endl; //子类 4字节
      
    Derive* d = new Derive(); //派生类指针
    long* pvptr = (long*)d; //指向对象的指针d转成了long*类型
    long* vptr = (long*)(*pvptr); //(*pvptr)表示pvptr所指向的对象，也就是Derive本身， Derive对象是4字节，代表的是虚函数表指针

    for (int i = 0; i <= 2; i++) //循环3次 打印虚函数的入口地址
    {
        printf("vptr[%d] = 0x:%p\n", i, vptr[i]);
    }
    
    Derive* d_2 = new Derive(); //派生类指针
    long* pvptr_2 = (long*)d_2; //指向对象的指针d转成了long*类型
    long* vptr_2 = (long*)(*pvptr_2); //(*pvptr)表示pvptr所指向的对象，也就是Derive本身， Derive对象是4字节，代表的是虚函数表指针

    for (int i = 0; i <= 2; i++) //循环3次 打印虚函数的入口地址
    {
        printf("vptr_2[%d] = 0x:%p\n", i, vptr_2[i]);
    }

    return 0;
}

  • 父类中有虚函数，子类中有虚函数；即父类中有虚函数表，子类中肯定也有虚函数表；

  • 无论是父类还是子类都会只有一个虚函数表，不能认为子类中有一个虚函数表 + 父类中一个虚函数表，得到子类中有两个虚函数表；

    子类中是否可能有多个虚函数表？

  • 如果子类中完全没有新的虚函数，则我们可以认为子类的虚函数表和父类的虚函数表内容相同；但仅仅是内容相同，这两个表在内存中处于不同位置；

  • 虚函数表中每一项，保存一个虚函数的入口地址，如果子类的虚函数表某项和父类虚函数表某项相同（这表示子类没有覆盖父类的虚函数）；

  • 超出虚函数表部分内容不可知；无实际意义；

// objModel.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//基类不同对象虚函数指针
//基类和父类对象 虚函数指针

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void func()
    {
        cout << "Base::void func()" << endl;
    }

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


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


class Derive :public Base
{
public:
    virtual void gunc()
    {
        cout << "Derive::void hunc()" << endl;
    }
};

int main()
{
    //直接用类名和用对象一样，都是这个类的对象的大小
    cout << sizeof(Base) << endl; //父类 4字节
    cout << sizeof(Derive) << endl; //子类 4字节
    
    
    Derive derive; //__vfptr = 0x00f89b90 {objModel.exe!void(* Derive::`vftable'[4])()} {0x00f812da {objModel.exe!Base::func(void)}, ...}
    long* p_vptr_derive = (long*)(&derive); //指向对象的指针d转成了long*类型
    long* vptr_derive = (long*)(*p_vptr_derive); //(*pvptr)表示pvptr所指向的对象，也就是Derive本身， Derive对象是4字节，代表的是虚函数表指针

    typedef void(*Func)(void); //定义一个函数指针类型
    Func f = (Func)vptr_derive[0]; //f是函数指针变量，vptr_derive[0]是指向第一个虚函数；
    Func g = (Func)vptr_derive[1]; //f是函数指针变量，vptr_derive[1]是指向第二个虚函数；
    Func h = (Func)vptr_derive[2]; //f是函数指针变量，vptr_derive[2]是指向第三个虚函数；



    Derive derive_2 = derive; //调用拷贝构造函数  __vfptr = 0x00f89b90 {objModel.exe!void(* Derive::`vftable'[4])()} {0x00f812da {objModel.exe!Base::func(void)}, ...}
    long* p_vptr_derive_2 = (long*)(&derive_2); //指向对象的指针d转成了long*类型
    long* vptr_derive_2 = (long*)(*p_vptr_derive_2); //(*pvptr)表示pvptr所指向的对象，也就是Derive本身， Derive对象是4字节，代表的是虚函数表指针


    Func f_2 = (Func)vptr_derive_2[0]; //f是函数指针变量，vptr_derive[0]是指向第一个虚函数；
    Func g_2 = (Func)vptr_derive_2[1]; //f是函数指针变量，vptr_derive[1]是指向第二个虚函数；
    Func h_2 = (Func)vptr_derive_2[2]; //f是函数指针变量，vptr_derive[2]是指向第三个虚函数；



    //直接用子类对象给父类对象值，子类中属于分类的那部分内容会被编译器自动区分出来，并拷贝给了父类对象
    //所以Base base = derive; 实际上做了两件事
    //1. 生成一个base对象
    //2. 用derive来初始化base对象的值，编译器做了选择，derive的虚函数表指针值并没有覆盖base对象的虚函数表指针值；
    Base base = derive; //直接用子类对象给父类对象值 __vfptr = 0x00f89b34 {objModel.exe!void(* Base::`vftable'[4])()} {0x00f812da {objModel.exe!Base::func(void)}, ...}
    long* p_vptr_base = (long*)(&base); //指向对象的指针d转成了long*类型
    long* vptr_base = (long*)(*p_vptr_base); //(*

    Func f_base = (Func)vptr_base[0]; //f是函数指针变量，vptr_derive[0]是指向第一个虚函数；
    Func g_base = (Func)vptr_base[1]; //f是函数指针变量，vptr_derive[1]是指向第二个虚函数；
    Func h_base = (Func)vptr_base[2]; //f是函数指针变量，vptr_derive[2]是指向第三个虚函数；


    //面向对象oo和基于对象ob
    // 1. C++通过类的指针和引用来支持多态，就是面向对象OO；
    // 2. OB，也叫ADT抽象数据模型，不支持多态，执行速度更快，因为函数调用的解析不需要运行时决定（没有多态）
    //    因为函数调用的解析不需要运行时决定（没有多态），而是在编译器期间就解析完成，内存空间紧凑程度上更紧凑，因为没有虚函数指针和虚函数表这些概念；
    //    但是OB的设计灵活性就差；

    //C++既支持OO，有支持OB；

    return 0;
}

多重继承虚函数表分析

  • 一个对象，如果它的类有多个基类则有多个虚函数表指针（注意是两个虚函数表指针，而不是两个虚函数表）;

  • 在多继承中，对应各个基类的vptr按照继承顺序依次放置在类的内存空间中，且子类与第一个基类公用一个vptr（第二个基类有自己的vptr）;

  • 子类对象有两个虚函数表指针，vptr1和vptr2；

  • 类Derived有两个虚函数表，因为它继承自两个基类；

  • 子类和第一个基类公用一个vptr（应为vptr指向一个虚函数表，所以也可以说子类和第一个基类公用一个虚函数表vtb1）

    因为我们注意到类Dreived的虚函数表1里面的5个函数u，g正好是基类1里面的函数；

  • 子类中的虚函数覆盖了父类中的同名虚函数；


#include <iostream>
using namespace std;



class Base_1
{
public:
	virtual void func()
	{
		cout << "Base_1::void func()" << endl;
	}

	virtual void gunc()
	{
		cout << "Base_1::void gunc()" << endl;
	}
};



class Base_2
{
public:
	virtual void hunc()
	{
		cout << "Base_2::void func()" << endl;
	}

	virtual void iunc()
	{
		cout << "Base_2::void gunc()" << endl;
	}
};




class Derived :public Base_1, public Base_2
{
public:
	virtual void func()
	{
		cout << "Derived::void func()" << endl;
	}
	virtual void iunc()
	{
		cout << "Derived::void iunc()" << endl;
	}



	//自己的虚函数
	virtual void munc()
	{
		cout << "Derived::void munc()" << endl;
	}
	virtual void nunc()
	{
		cout << "Derived::void nunc()" << endl;
	}
	virtual void junc()
	{
		cout << "Derived::void junc()" << endl;
	}
};

int main()
{
	//多重继承虚函数表分析
	cout << sizeof(Base_1) << endl;
	cout << sizeof(Base_2) << endl;
	cout << sizeof(Derived) << endl;

	Derived derive;
	Base_1& b_1 = derive;
	Base_2& b_2 = derive;
	Derived& d = derive;


	typedef void(*Func)(void);

	long* p_derived_1 = (long*)(&derive);
	long* vptr_1 = (long*)(*p_derived_1); //取第一个虚函数表指针



	long* p_derived_2 = p_derived_1 + 1; 
	long* vptr_2 = (long*)(*p_derived_2); //取第二个虚函数表指针



	Func f_1_1 = (Func)vptr_1[0]; //f_1_1 = 0x0039146f {objModel.exe!Derived::func(void)}
	Func f_1_2 = (Func)vptr_1[1]; //f_1_2 = 0x00141460 {objModel.exe!Base_1::gunc(void)}
	Func f_1_3 = (Func)vptr_1[2]; //f_1_3 = 0x00141483 {objModel.exe!Derived::munc(void)}
	Func f_1_4 = (Func)vptr_1[3]; //f_1_4 = 0x00141492 {objModel.exe!Derived::nunc(void)}
	Func f_1_5 = (Func)vptr_1[4]; //f_1_5 = 0x0014146a {objModel.exe!Derived::junc(void)}

	Func f_2_1 = (Func)vptr_2[0]; //f_2_1 = 0x00141479 {objModel.exe!Base_2::hunc(void)}
	Func f_2_2 = (Func)vptr_2[1]; //f_2_2 = 0x0014145b {objModel.exe!Derived::iunc(void)}

	f_1_1();
	f_1_2();
	f_1_3();
	f_1_4();
	f_1_5();

	cout << "-----------------------------" << endl;

	f_2_1();
	f_2_2();


	//

	return 0;
}

vptr/vtbl创建时机

辅助工具： **cl.exe ** 编译链接工具

虚函数调用问题

猜你喜欢

转载自www.cnblogs.com/Trevo/p/13367558.html
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
NEFU 117 素数个数的位数
Closest Common Ancestors (Lca,tarjan)
ELK部署
【转载】Hive笔记整理（三）
SQL语句（一）基本表的定义
关于Java web开发中的MySQL的事务语句
MFC创建自定义窗体
如何用一句话激怒程序员？
《逆袭大学》文摘——9.4 基础和应用的平衡中找到大学的节奏
【spring源码分析】@Value注解原理
每日归档
更多
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022