C++虚函数表、地址详解（x86/x64）

已于 2024-08-08 19:12:46 修改
阅读量438 收藏 19
点赞数 10
分类专栏： C++ 文章标签： c++
于 2024-08-08 19:01:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuemouren/article/details/141033313
版权

参考博文：c++虚函数表、地址详解-CSDN博客

本文在上述博文的基础上，补充了x64下的验证代码。

一.什么是虚函数表，它有什么特点？

        虚函数大家都知道是基本用于实现多态的，当父类指针指向子类对象的时候，如何确定调用的函数是父类里的还是子类里面的，这就要用到虚函数表。下面一点点表诉什么是虚函数表，和虚函数表的特点。如有说错的地方，欢迎指正：

1.编译器会为每个有虚函数的类创建一个虚函数表

        如有类中没有虚函数，那么这个虚函数表就不存在，而不是表中无数据。同时，有虚函数的类都会有自己的虚函数表，一个类不会有另外一个类的虚函数表，包括两个类属于继承关系。

2.虚函数表会被一个类的所有对象所拥有

        类的每个虚函数成员占据虚函数表的一行，所以说，如果类中有N个虚函数,那么该虚函数表将会有N*8的大小（x64）。并不是每个类对象都会有自己的表。

3.编译器会将虚函数表指针存放在类对象最前面的位置

        对于类的每个对象，编译器都会为其生成一个透明不可见的指针，这个指针就是虚函数表指针，存放在该对象内存的最前位置。例如：一个类拥有虚函数表，类对象内存布局中前8个字节就是虚函数表的地址（64位）。这个接下来我们会进行测试。

4.延伸，由第一条可知，子类继承父类，其虚函数表和表函数地址是不一样的。

5.父类指针指向子类对象时，调用时实际上是根据子类对象的虚函数表进行查找。

6.如果父类有虚函数，子类没有定义虚函数，那么子类也会有虚函数表。

二.测试

1.测试虚函数表地址和虚函数地址
#include <stdio.h>
#include <stdlib.h>
#include <iostream>

#ifdef _WIN64
#define PTR_VAL int64_t
#else
#define PTR_VAL int32_t
#endif

using namespace std;

class Father
{
	virtual void FatherFun1() { cout << "FatherFun1" << endl; }
	virtual void FatherFun2() { cout << "FatherFun2" << endl; }
	virtual void FatherFun3() { cout << "FatherFun3" << endl; }
};

typedef void (*Fun)(void);

int main()
{
	Father father;
	cout << "类对象地址：" << &father << endl;
	cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&father << endl;
	cout << "虚函数FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&father << endl;
	cout << "虚函数FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 1 << endl;
	cout << "虚函数FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 2 << endl;

	cout << "测试地址是否正确" << endl;
	Fun fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&father;
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 1);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 2);
	fun();

	system("pause");
}

         上面说过, x64下，类对象内存中前8个字节就是虚函数表的地址，那么我们获取类对象前8个字节，（int64_t）&father就是虚函数表地址，我们再给他转换成地址指针为（int64_t*)（int64_t）&father。然后我们在看一下输出结果：

类对象地址：000000ADA0B2F768
虚函数表地址: 00007FF7FEAABCB0
虚函数FatherFun1地址：00007FF7FEAABCB0
虚函数FatherFun2地址：00007FF7FEAABCB8
虚函数FatherFun3地址：00007FF7FEAABCC0
测试地址是否正确
FatherFun1
FatherFun2
FatherFun3
请按任意键继续. . .

        从这个输出我们可以看到，FatherFun1、FatherFun2、FatherFun3的地址只差了8个字节，且输出是正确的，那么第三点已确认！

2.多个类对象的虚函数表地址

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#ifdef _WIN64
#define PTR_VAL int64_t
#else
#define PTR_VAL int32_t
#endif
using namespace std;

class Father
{
	virtual void FatherFun1() { cout << "FatherFun1" << endl; }
	virtual void FatherFun2() { cout << "FatherFun2" << endl; }
	virtual void FatherFun3() { cout << "FatherFun3" << endl; }
};

typedef void (*Fun)(void);

int main()
{

	Father father;
	cout << "类对象地址：" << &father << endl;
	cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&father << endl;
	cout << "虚函数FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&father << endl;
	cout << "虚函数FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 1 << endl;
	cout << "虚函数FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 2 << endl;

	cout << "第二个类对象" << endl;

	Father father1;
	cout << "类对象地址：" << &father1 << endl;
	cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&father1 << endl;
	cout << "虚函数FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&father1 << endl;
	cout << "虚函数FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&father1 + 1 << endl;
	cout << "虚函数FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&father1 + 2 << endl;

	system("pause");
}

定义了两个对象，分别看两个对象的虚函数表地址是否正确，发现两个类对象虚函数表地址相同。

以下为输出：

类对象地址：00000070C3DCFC18
虚函数表地址: 00007FF775FCBCF8
虚函数FatherFun1地址：00007FF775FCBCF8
虚函数FatherFun2地址：00007FF775FCBD00
虚函数FatherFun3地址：00007FF775FCBD08
第二个类对象
类对象地址：00000070C3DCFC38
虚函数表地址: 00007FF775FCBCF8
虚函数FatherFun1地址：00007FF775FCBCF8
虚函数FatherFun2地址：00007FF775FCBD00
虚函数FatherFun3地址：00007FF775FCBD08
请按任意键继续. . .

由此可见，第二点现在已经确认！

3.测试类中无虚函数，是否存在虚函数表

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#ifdef _WIN64
#define PTR_VAL int64_t
#else
#define PTR_VAL int32_t
#endif
using namespace std;

class Test
{
	void TestFun1() { cout << "TestFun1" << endl; }
	void TestFun2() { cout << "TestFun2" << endl; }
	void TestFun3() { cout << "TestFun3" << endl; }
};

typedef void (*Fun)(void);

int main()
{
	Test test;
	cout << "类对象地址：" << &test << endl;
	cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&test << endl;
	cout << "虚函数TestFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&test << endl;
	cout << "虚函数TestFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&test + 1 << endl;
	cout << "虚函数TestFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&test + 2 << endl;

	system("pause");
}

以下为输出：

类对象地址：000000AEBF9DFB44
虚函数表地址: CCCCCCCCCCCCCCCC
虚函数TestFun1地址：CCCCCCCCCCCCCCCC
虚函数TestFun2地址：CCCCCCCCCCCCCCD4
虚函数TestFun3地址：CCCCCCCCCCCCCCDC
请按任意键继续. . .

由此可见虚函数表地址为错误，第一条确认！

4.子类继承父类，但不继承虚函数表

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#ifdef _WIN64
#define PTR_VAL int64_t
#else
#define PTR_VAL int32_t
#endif
using namespace std;

class Father
{
    virtual void FatherFun1() { cout << "FatherFun1" << endl; }
    virtual void FatherFun2() { cout << "FatherFun2" << endl; }
    virtual void FatherFun3() { cout << "FatherFun3" << endl; }
};

class Son : public Father
{
    virtual void SonFun1() { cout << "SonFun1" << endl; }
    virtual void SonFun2() { cout << "SonFun2" << endl; }
    virtual void SonFun3() { cout << "SonFun3" << endl; }
};

typedef void (*Fun)(void);

int main()
{
    Father father;
    cout << "类对象地址：" << &father << endl;
    cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&father << endl;
    cout << "虚函数FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&father << endl;
    cout << "虚函数FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 1 << endl;
    cout << "虚函数FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 2 << endl;
    //cout << "虚函数sonFun1地址：" <<(PTR_VAL*)*(PTR_VAL*)&father + 3 << endl;
    //cout << "虚函数sonFun2地址：" <<(PTR_VAL*)*(PTR_VAL*)&father + 4 << endl;
    //cout << "虚函数sonFun3地址：" <<(PTR_VAL*)*(PTR_VAL*)&father + 5 << endl;
    Fun fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&father;
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 1);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 2);
    fun();
    //fun = (Fun)*((PTR_VAL*)*(PTR_VAL*)(&father) + 3);
    //fun();
    //fun = (Fun)*((PTR_VAL*)*(PTR_VAL*)(&father) + 4);
    //fun();
    //fun = (Fun)*((PTR_VAL*)*(PTR_VAL*)(&father) + 5);
    //fun();

    cout << "----------------测试子类------------------" << endl;

    Son son;
    cout << "类对象地址：" << &son << endl;
    cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&son << endl;
    cout << "虚函数继承FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&son << endl;
    cout << "虚函数继承FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 1 << endl;
    cout << "虚函数继承FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 2 << endl;
    cout << "虚函数sonFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 3 << endl;
    cout << "虚函数sonFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 4 << endl;
    cout << "虚函数sonFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 5 << endl;
    fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&son;
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 1);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 2);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 3);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 4);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 5);
    fun();

    system("pause");
}

如果将代码中注释代码给恢复，会直接发生段错误。

以下为输出结果：

类对象地址：000000A9936FF9A8
虚函数表地址: 00007FF667CABCF8
虚函数FatherFun1地址：00007FF667CABCF8
虚函数FatherFun2地址：00007FF667CABD00
虚函数FatherFun3地址：00007FF667CABD08
FatherFun1
FatherFun2
FatherFun3
----------------测试子类------------------
类对象地址：000000A9936FF9E8
虚函数表地址: 00007FF667CABD50
虚函数继承FatherFun1地址：00007FF667CABD50
虚函数继承FatherFun2地址：00007FF667CABD58
虚函数继承FatherFun3地址：00007FF667CABD60
虚函数sonFun1地址：00007FF667CABD68
虚函数sonFun2地址：00007FF667CABD70
虚函数sonFun3地址：00007FF667CABD78
FatherFun1
FatherFun2
FatherFun3
SonFun1
SonFun2
SonFun3
请按任意键继续. . .

        由输出结果我们可以看到，父类和子类中的虚函数表地址是不一样的，而且子类继承了父类的虚函数，但是其地址是和父类中不一样的！。第四点确认！
        并且我们根据输出可以发现，子类虚函数表中虚函数地址排序为先是继承的父类的函数，再是子类中的虚函数。

5.子类重写父类中虚函数，或子类重定义父类虚函数

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#ifdef _WIN64
#define PTR_VAL int64_t
#else
#define PTR_VAL int32_t
#endif
using namespace std;

class Father
{
	virtual void FatherFun4() { cout << "FatherFun4" << endl; }
	virtual void FatherFun1() { cout << "FatherFun1" << endl; }
	virtual void FatherFun2() { cout << "FatherFun2" << endl; }
	virtual void FatherFun3() { cout << "FatherFun3" << endl; }
};

class Son : public Father
{
	virtual void SonFun1() { cout << "SonFun1" << endl; }
	virtual void SonFun2() { cout << "SonFun2" << endl; }
	virtual void SonFun3() { cout << "SonFun3" << endl; }
	virtual void FatherFun4() { cout << "SonGetFatherFun4" << endl; }
	virtual void FatherFun4(int a = 0) { cout << "SonGetFatherFun4 diffrent param" << endl; }
};

typedef void (*Fun)(void);
typedef void (*FunParam)(int);

int main()
{
#if 1
	Father father;
	cout << "类对象地址：" << &father << endl;
	cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&father << endl;
	cout << "虚函数FatherFun4地址：" << (PTR_VAL*)*(PTR_VAL*)&father << endl;
	cout << "虚函数FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 1 << endl;
	cout << "虚函数FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 2 << endl;
	cout << "虚函数FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 3 << endl;
	Fun fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&father;
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 1);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 2);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 3);
	fun();


	cout << "----------------测试子类------------------" << endl;

	Son son;
	cout << "类对象地址：" << &son << endl;
	cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&son << endl;
	cout << "虚函数继承SonGetFatherFun4地址：" << (PTR_VAL*)*(PTR_VAL*)&son << endl;
	cout << "虚函数继承FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 1 << endl;
	cout << "虚函数继承FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 2 << endl;
	cout << "虚函数继承FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 3 << endl;
	cout << "虚函数sonFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 4 << endl;
	cout << "虚函数sonFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 5 << endl;
	cout << "虚函数sonFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 6 << endl;
	cout << "虚函数SonGetFatherFun4 diffrent param地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 7 << endl;
	fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&son;
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 1);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 2);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 3);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 4);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 5);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 6);
	fun();
	FunParam funParam = (FunParam) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 7);
	funParam(0);
#endif
	system("pause");
}

        我们故意将父类中FatherFun4放在最前，而子类中的重写和重定义的FatherFun4 函数放在最后，看一下虚函数表中虚函数排放顺序是否有发生改变。

以下为输出结果：

虚函数FatherFun1地址：00007FF76199BD00
虚函数FatherFun2地址：00007FF76199BD08
虚函数FatherFun3地址：00007FF76199BD10
FatherFun4
FatherFun1
FatherFun2
FatherFun3
----------------测试子类------------------
类对象地址：0000003360F5F648
虚函数表地址: 00007FF76199BD68
虚函数继承SonGetFatherFun4地址：00007FF76199BD68
虚函数继承FatherFun1地址：00007FF76199BD70
虚函数继承FatherFun2地址：00007FF76199BD78
虚函数继承FatherFun3地址：00007FF76199BD80
虚函数sonFun1地址：00007FF76199BD88
虚函数sonFun2地址：00007FF76199BD90
虚函数sonFun3地址：00007FF76199BD98
虚函数SonGetFatherFun4 diffrent param地址：00007FF76199BDA0
SonGetFatherFun4
FatherFun1
FatherFun2
FatherFun3
SonFun1
SonFun2
SonFun3
SonGetFatherFun4 diffrent param
请按任意键继续. . .

        我们可以清楚的看到，位于子类最后函数重写的FatherFun4被放在了本该继承的父类FatherFun4位置上（先输出的是SonGetFatherFun4），而函数重定义则没有发生改变。

由此可以得出结论：

（1）覆盖的FatherFun4函数被放到了虚函数表中原父类虚函数的位置

（2）没有被覆盖的函数没有变化

6.子类指针指向父类

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#ifdef _WIN64
#define PTR_VAL int64_t
#else
#define PTR_VAL int32_t
#endif
using namespace std;

class Father
{
	virtual void FatherFun1() { cout << "FatherFun1" << endl; }
	virtual void FatherFun2() { cout << "FatherFun2" << endl; }
	virtual void FatherFun3() { cout << "FatherFun3" << endl; }
};

class Son : public Father
{
	virtual void SonFun1() { cout << "SonFun1" << endl; }
	virtual void SonFun2() { cout << "SonFun2" << endl; }
	virtual void SonFun3() { cout << "SonFun3" << endl; }
};

#if 0
class Test
{
	void TestFun1() { cout << "TestFun1" << endl; }
	void TestFun2() { cout << "TestFun2" << endl; }
	void TestFun3() { cout << "TestFun3" << endl; }
};
#endif

typedef void (*Fun)(void);
typedef void (*FunParam)(int);

int main()
{
	cout << "----------------测试父类------------------" << endl;
	Father father;
	cout << "类对象地址：" << &father << endl;
	cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&father << endl;
	cout << "虚函数FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&father << endl;
	cout << "虚函数FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 1 << endl;
	cout << "虚函数FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 2 << endl;

	Fun fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&father;
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 1);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 2);
	fun();


	cout << "----------------测试子类------------------" << endl;
	Son son;
	cout << "类对象地址：" << &son << endl;
	cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&son << endl;
	cout << "虚函数继承FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&son << endl;
	cout << "虚函数继承FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 1 << endl;
	cout << "虚函数继承FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 2 << endl;
	cout << "虚函数sonFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 3 << endl;
	cout << "虚函数sonFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 4 << endl;
	cout << "虚函数sonFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 5 << endl;
	fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&son;
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 1);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 2);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 3);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 4);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 5);
	fun();

	cout << "----------------测试父类指针指向子类------------------" << endl;
	Father* pointSon = new Son;
	cout << "类对象地址：" << pointSon << endl;
	cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)pointSon << endl;
	cout << "虚函数继承FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon << endl;
	cout << "虚函数继承FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon + 1 << endl;
	cout << "虚函数继承FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon + 2 << endl;
	cout << "虚函数sonFun1地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon + 3 << endl;
	cout << "虚函数sonFun2地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon + 4 << endl;
	cout << "虚函数sonFun3地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon + 5 << endl;
	fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)pointSon;
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+1);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+2);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+3);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+4);
	fun();
	fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+5);
	fun();

	system("pause");
}

实际上父类指针指向子类，调用的是子类的虚函数表。

以下为输出：

类对象地址：00000058117AF688
虚函数表地址: 00007FF6F469CD50
虚函数继承FatherFun1地址：00007FF6F469CD50
虚函数继承FatherFun2地址：00007FF6F469CD58
虚函数继承FatherFun3地址：00007FF6F469CD60
虚函数sonFun1地址：00007FF6F469CD68
虚函数sonFun2地址：00007FF6F469CD70
虚函数sonFun3地址：00007FF6F469CD78
FatherFun1
FatherFun2
FatherFun3
SonFun1
SonFun2
SonFun3
----------------测试父类指针指向子类------------------
类对象地址：0000021C918185C0
虚函数表地址: 00007FF6F469CD50
虚函数继承FatherFun1地址：00007FF6F469CD50
虚函数继承FatherFun2地址：00007FF6F469CD58
虚函数继承FatherFun3地址：00007FF6F469CD60
虚函数sonFun1地址：00007FF6F469CD68
虚函数sonFun2地址：00007FF6F469CD70
虚函数sonFun3地址：00007FF6F469CD78
FatherFun1
FatherFun2
FatherFun3
SonFun1
SonFun2
SonFun3
请按任意键继续. . .

        由虚函数表地址我们就可以看到，父类指针指向子类的时候，其虚函数表地址和子类虚函数表地址是一样的。由此，第五点确认。

7.子类重写父类虚函数，并父类指针指向子类

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#ifdef _WIN64
#define PTR_VAL int64_t
#else
#define PTR_VAL int32_t
#endif
using namespace std;

class Father
{
    virtual void FatherFun4() { cout << "FatherFun4" << endl; }
    virtual void FatherFun1() { cout << "FatherFun1" << endl; }
    virtual void FatherFun2() { cout << "FatherFun2" << endl; }
    virtual void FatherFun3() { cout << "FatherFun3" << endl; }
};

class Son : public Father
{
    virtual void SonFun1() { cout << "SonFun1" << endl; }
    virtual void SonFun2() { cout << "SonFun2" << endl; }
    virtual void SonFun3() { cout << "SonFun3" << endl; }
    virtual void FatherFun4() { cout << "SonGetFatherFun4" << endl; }
};

#if 0
class Test
{
    void TestFun1() { cout << "TestFun1" << endl; }
    void TestFun2() { cout << "TestFun2" << endl; }
    void TestFun3() { cout << "TestFun3" << endl; }
};
#endif

typedef void (*Fun)(void);
typedef void (*FunParam)(int);

int main()
{
    cout << "----------------测试父类------------------" << endl;
    Father father;
    cout << "类对象地址：" << &father << endl;
    cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&father << endl;
    cout << "虚函数FatherFun4地址：" << (PTR_VAL*)*(PTR_VAL*)&father << endl;
    cout << "虚函数FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 1 << endl;
    cout << "虚函数FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 2 << endl;
    cout << "虚函数FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 3 << endl;

    Fun fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&father;
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 1);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 2);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 3);
    fun();

    cout << "----------------测试子类------------------" << endl;
    Son son;
    cout << "类对象地址：" << &son << endl;
    cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&son << endl;
    cout << "虚函数继承FatherFun4地址：" << (PTR_VAL*)*(PTR_VAL*)&son << endl;
    cout << "虚函数继承FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 1 << endl;
    cout << "虚函数继承FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 2 << endl;
    cout << "虚函数继承FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 3 << endl;
    cout << "虚函数sonFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 4 << endl;
    cout << "虚函数sonFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 5 << endl;
    cout << "虚函数sonFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 6 << endl;
    fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&son;
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 1);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 2);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 3);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 4);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 5);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 6);
    fun();


    cout << "----------------测试父类指针指向子类------------------" << endl;
    Father* pointSon = new Son;
    cout << "类对象地址：" << pointSon << endl;
    cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)pointSon << endl;
    cout << "虚函数继承FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon << endl;
    cout << "虚函数继承FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon + 1 << endl;
    cout << "虚函数继承FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon + 2 << endl;
    cout << "虚函数sonFun1地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon + 3 << endl;
    cout << "虚函数sonFun2地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon + 4 << endl;
    cout << "虚函数sonFun3地址：" << (PTR_VAL*)*(PTR_VAL*)pointSon + 5 << endl;
    fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)pointSon;
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+1);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+2);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+3);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+4);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+5);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(pointSon)+6);
    fun();

    system("pause");
}

直接看输出结果：

----------------测试父类------------------
类对象地址：000000555C70FBF8
虚函数表地址: 00007FF61736CCF8
虚函数FatherFun4地址：00007FF61736CCF8
虚函数FatherFun1地址：00007FF61736CD00
虚函数FatherFun2地址：00007FF61736CD08
虚函数FatherFun3地址：00007FF61736CD10
FatherFun4
FatherFun1
FatherFun2
FatherFun3
----------------测试子类------------------
类对象地址：000000555C70FC38
虚函数表地址: 00007FF61736CD68
虚函数继承FatherFun4地址：00007FF61736CD68
虚函数继承FatherFun1地址：00007FF61736CD70
虚函数继承FatherFun2地址：00007FF61736CD78
虚函数继承FatherFun3地址：00007FF61736CD80
虚函数sonFun1地址：00007FF61736CD88
虚函数sonFun2地址：00007FF61736CD90
虚函数sonFun3地址：00007FF61736CD98
SonGetFatherFun4
FatherFun1
FatherFun2
FatherFun3
SonFun1
SonFun2
SonFun3
----------------测试父类指针指向子类------------------
类对象地址：0000019CE3F99140
虚函数表地址: 00007FF61736CD68
虚函数继承FatherFun1地址：00007FF61736CD68
虚函数继承FatherFun2地址：00007FF61736CD70
虚函数继承FatherFun3地址：00007FF61736CD78
虚函数sonFun1地址：00007FF61736CD80
虚函数sonFun2地址：00007FF61736CD88
虚函数sonFun3地址：00007FF61736CD90
SonGetFatherFun4
FatherFun1
FatherFun2
FatherFun3
SonFun1
SonFun2
SonFun3
请按任意键继续. . .

实际上和第六点结果是一样的。

8.如果父类有虚函数，子类没有定义虚函数，子类也会有虚函数表

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#ifdef _WIN64
#define PTR_VAL int64_t
#else
#define PTR_VAL int32_t
#endif
using namespace std;

class Father
{
    virtual void FatherFun1() { cout << "FatherFun1" << endl; }
    virtual void FatherFun2() { cout << "FatherFun2" << endl; }
    virtual void FatherFun3() { cout << "FatherFun3" << endl; }
};

class Son : public Father
{
    //virtual void SonFun1() { cout << "SonFun1" << endl; }
    //virtual void SonFun2() { cout << "SonFun2" << endl; }
    //virtual void SonFun3() { cout << "SonFun3" << endl; }
};

typedef void (*Fun)(void);

int main()
{
    Father father;
    cout << "类对象地址：" << &father << endl;
    cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&father << endl;
    cout << "虚函数FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&father << endl;
    cout << "虚函数FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 1 << endl;
    cout << "虚函数FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&father + 2 << endl;

    Fun fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&father;
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 1);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&father) + 2);
    fun();

    cout << "----------------测试子类------------------" << endl;

    Son son;
    cout << "类对象地址：" << &son << endl;
    cout << "虚函数表地址: " << (PTR_VAL*)*(PTR_VAL*)&son << endl;
    cout << "虚函数继承FatherFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&son << endl;
    cout << "虚函数继承FatherFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 1 << endl;
    cout << "虚函数继承FatherFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 2 << endl;
    //cout << "虚函数sonFun1地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 3 << endl;
    //cout << "虚函数sonFun2地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 4 << endl;
    //cout << "虚函数sonFun3地址：" << (PTR_VAL*)*(PTR_VAL*)&son + 5 << endl;
    fun = (Fun) * (PTR_VAL*)*(PTR_VAL*)&son;
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 1);
    fun();
    fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 2);
    fun();
    //fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 3);
    //fun();
    //fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 4);
    //fun();
    //fun = (Fun) * ((PTR_VAL*)*(PTR_VAL*)(&son) + 5);
    //fun();

    system("pause");
}

        将子类中的虚函数注释掉，输出结果：

类对象地址：00000097B6CFF958
虚函数表地址: 00007FF6E459BCF8
虚函数FatherFun1地址：00007FF6E459BCF8
虚函数FatherFun2地址：00007FF6E459BD00
虚函数FatherFun3地址：00007FF6E459BD08
FatherFun1
FatherFun2
FatherFun3
----------------测试子类------------------
类对象地址：00000097B6CFF998
虚函数表地址: 00007FF6E459BD50
虚函数继承FatherFun1地址：00007FF6E459BD50
虚函数继承FatherFun2地址：00007FF6E459BD58
虚函数继承FatherFun3地址：00007FF6E459BD60
FatherFun1
FatherFun2
FatherFun3
请按任意键继续. . .

  第6条确认。

飞翔的小七
关注
  • 10
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++虚函数表解析--基于陈皓版
Haiboy的博客
03-03 466
前言  看了陈皓大佬的文章《C++ 虚函数表解析》后，在自己理解上出现一些问题，验证后明了写出此文章。前提不是说大佬写错了，而是我看明白了。  直接写出问题结论：C++的虚函数表是类对象共享的，而类实例的虚函数表存放的是唯一虚函数的地址(即这是地址表)，不存在每一个类实例都建立虚函数  下面我们开始验证过程。 虚函数表  学习C++的人都知道类实例建立时的栈内存分布最前面位置是一个虚函数表指针(v...
linux x86_64 的虚函数表
angelazhao620的博客
07-15 118
虚函数表
C++ 虚函数表及调用规范详解
qq_32506555的博客
10-17 525
在支付工具想做社交，即时通讯工具想做app市场，英语字典想做新闻社交的今天，创造这些怪象的公司要求程序员懂得更多几乎是理所当然的，毕竟现在大家什么都想做。这不，正值招聘季，实验室的几位学长也是一直在讨论各种问题，发现对于C++语言而言，问的最多的还是虚函数表和STL。 STL的考点至少是实用的，哪怕要求你读过源码，也并不过分，毕竟知根知底才能更好地应用。但要求程序员掌握对象模型着实拎不清，因
C++多态详解（虚函数重写、接口继承、虚函数表详解）
bang___bang_的博客
05-24 2132
本文详细讲解多态，并且深析多态原理及虚函数表，各继承下的虚函数表存的虚函数指针情况，引用例子生动讲解多态，虚函数重写，接口继承。
【C++】多态|原理|override|final|抽象类|多继承虚函数表|对象模型|虚表打印|（万字详解版）
m0_67367079的博客
06-16 677
C++11引入了override和final两个关键字，它们增强了面向对象编程中的继承和多态特性，提高了代码的安全性和可读性。虚函数自身自带一个_vfptr的虚函数表子类虚函数继承父类虚函数时，不仅继承父类虚函数表，也可以对虚函数进行重写。子类虚函数继承父类虚函数时，非虚函数不会存放在_vfptr中虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。
C++之深入解析虚函数表的实现及其内存布局
╰つ栺尖篴夢ゞ
04-17 1200
C++ 中的虚函数的作用主要是实现了多态的机制，关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数：Derive d;b1 -> f();这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI 技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。
C++_知识点——虚函数
weixin_43945471的博客
03-13 371
C++_知识点——虚函数
C++重点（提高）多态与虚函数——深入了解虚函数表与多态
m0_74045201的博客
10-31 78
继承、封装、多态是C++的三大特性，而其中多态技术则通过虚函数实现来体现，而虚函数的机理是大多数课程中所不曾涉及的，但是对于虚函数表和多态的掌握，还意味着在实际开发中程序员能充分地利用C++面向对象编程中的多态技术，写出高扩展性以及耦合度较低的优质代码。
C++之多态详解
be_a_struggler的博客
11-15 2140
C++多态，多态的概念，多态的定义及实现，虚函数，虚函数的重写，抽象类，多态的原理，单继承和多继承关系中的虚函数表 多态常见的面试题
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型...
C/C++ 进程无模块内存注入[x86/x64]
05-30
本文将深入探讨“C/C++ 进程无模块内存注入[x86/x64]”这一主题，涵盖Windows下的R3无模块注入技术，以及如何实现对x86和x64架构的通用支持。 首先，我们要理解什么是“进程无模块内存注入”。通常，内存注入涉及到...
C++类对象关于虚函数表详解
03-14
《C++类对象关于虚函数表详解》 C++中的虚函数是实现多态性的重要机制，它允许通过基类指针调用派生类的重写函数，从而展现出多种形态，这是一种典型的泛型技术。泛型技术的目标是用统一的代码处理不同类型的数据或...
C++ 龙马谷代码注入器 支持x86/x64汇编 DLL注入
04-02
2. x86/x64兼容性：由于现代计算机系统有32位和64位两种架构，C++龙马谷代码注入器同时支持x86和x64汇编，可以处理不同架构下的DLL注入问题。在不同的体系结构中，内存管理和函数调用约定有所不同，因此需要编写对应...
C++虚函数表实例分析
01-21
在对象中，有一个指针指向一张虚函数表，里面按照次序存放了每一个虚函数，当子类继承的时候，即到虚函数表的指定位置去修改函数地址。当我们通过父类指针来操作一个子类的时候，调用虚函数，都是通过虚函数表+固定...
c++ error: ‘*’ does not name a type； did you mean ‘**’?
最新发布
xiaozhi
08-08 73
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 203
STL中的迭代器失效（vector为例）
C++ STL copy_backward, move_backward 用法
08-04 278
此处需要解释一下：从后向前并不是逆序，它的意思是: 源容器和目标容器都从尾部开始，然后向前迭代，执行拷贝/移动操作。反向（从后向前的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
C++ - 函数重载
jiaowenjie的专栏
08-06 264
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

飞翔的小七

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

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

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

打赏作者

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

抵扣说明：

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

余额充值