C++对象模型（剖析虚函数表）

最新推荐文章于 2023-10-17 10:56:39 发布
最新推荐文章于 2023-10-17 10:56:39 发布
阅读量601 收藏 2
点赞数 1
分类专栏： C++ 文章标签： 多态 C++ 虚函数表 对象模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23556715/article/details/51150104
版权

        多态是C++中一种代码复用的手段，什么叫多态？简单点说，就是多种形态。那么C++中是怎样实现多态的呢？

        在C++中，多态分为两种：静态多态与动态多态。静态多态是对象声明的类型是在编译时确定的，比如说函数重载，模板。动态多态是所指对象的类型是在运行时确定的。动态多态的实现是通过虚函数来完成的。我们可以通过基类的指针或引用来调用基类与子类的函数，这个过程就实现了多态。我们知道，多态是通过虚函数来实现的，那虚函数的背后又做了哪些事情呢，本篇文章主要来探讨虚函数的背后-->虚函数表。

一.普通继承（有虚函数，有成员变量，无虚函数覆盖）

在此种继承中，子类只继承于一个父类，没有对父类的虚函数进行重写，子类与父类都有各自的成员变量。

#include<iostream>
using namespace std;
typedef void(*FUNC)();
void PrintVTable(int p)
{
	int *ptr = (int*)p;
	FUNC fun = NULL;
	int i = 0;
	while (ptr[i])
	{
		fun = (FUNC)ptr[i];
		fun();
		i++;
	}
}
class Base
{
public :
	Base()
		:_b(10)
	{}
	 virtual void func1()
	{
		cout << "Base::func1()" << endl;
	}
	virtual void func2()
	{
		cout << "Base::func2()" << endl;
	}
private :
	int _b;
};
class Deriver:public Base
{
public:
	Deriver()
		:_d(20)
	{}
	virtual void func3()
	{
		cout << "Deriver::func3()" << endl;
	}
	virtual void func4()
	{
		cout << "Deriver::func4()" << endl;
	}
private:
	int _d;
};
int main()
{
	Base b;
	Deriver d;
	PrintVTable(*(int *)&b);
	cout << "----------------" << endl;
	PrintVTable(*(int *)&d);
	getchar();
	return 0;
}

我们可以通过监视窗口查看，大致的了解此种继承的对象模型。


         通过以上分析，我们可以知道，多态的背后是依靠虚函数表去实现的，虚函数表里面存储的是每个虚函数的地址，顺序按照声明顺序排列。其中this指针里面保存的是虚函数指针的地址。

下面是派生类的对象模型：



从以上模型中我们可以得出以下结论：

1.在对象模型中，起始的四个字节用来存放虚函数指针，其指向虚函数表。

2.成员变量按照其继承与生命的顺序依次存放。

3.父类的虚函数放在子类的虚函数前面。

二.单继承（有成员变量，有虚函数，有虚函数覆盖）

在此种继承中，子类只有一个父类，子类的成员函数有对父类的成员函数进行了重写，有各自的成员变量。

#include<iostream>
using namespace std;
typedef void(*FUNC)();
void PrintVTable(int p)
{
	int *ptr = (int*)p;
	FUNC fun = NULL;
	int i = 0;
	while (ptr[i])
	{
		fun = (FUNC)ptr[i];
		fun();
		i++;
	}
}
class Base
{
public :
	Base()
		:_b(10)
	{}
	 virtual void func1()
	{
		cout << "Base::func1()" << endl;
	}
	virtual void func2()
	{
		cout << "Base::func2()" << endl;
	}
private :
	int _b;
};
class Deriver:public Base
{
public:
	Deriver()
		:_d(20)
	{}
	virtual void func1()
	{
		cout << "Deriver::func1()" << endl;
	}
	virtual void func3()
	{
		cout << "Deriver::func3()" << endl;
	}
	virtual void func4()
	{
		cout << "Deriver::func4()" << endl;
	}
private:
	int _d;
};
int main()
{
	Base b;
	Deriver d;
	PrintVTable(*(int *)&b);
	cout << "----------------" << endl;
	PrintVTable(*(int *)&d);
	getchar();
	return 0;
}

我们可以通过调试窗口来观察子对象的大概模型。

下面是派生类的对象模型：

                                                                              

从以上模型中,我们可以得出以下结论：

当子类中有和父类同名的虚函数时，会形成覆盖，父类同名虚函数的地址会被子类同名函数的地址替换掉。此时用下面这种程序对派生类进行访问时，

Base *p=new Deriver;
p->func1();
调用的是派生类Deriver::func1(),即实现了多态。

三.多重继承（有成员变量，有虚函数，无虚函数覆盖）

#include<iostream>
using namespace std;
typedef void(*FUNC)();
void PrintVTable(int p)
{
	int *ptr = (int*)p;
	FUNC fun = NULL;
	int i = 0;
	while (ptr[i])
	{
		fun = (FUNC)ptr[i];
		fun();
		i++;
	}
}
class Base1
{
public :
	Base1()
		:_b1(10)
	{}
	 virtual void func1()
	{
		cout << "Base1::func1()" << endl;
	}
	
private :
	int _b1;
};
class Base2
{
public:
	Base2()
		:_b2(20)
	{}
	virtual void func2()
	{
		cout << "Base2::func2()" << endl;
	}
private:
	int _b2;
};
class Deriver:public Base1,public Base2
{
public:
	Deriver()
		:_d(30)
	{}
	virtual void func3()
	{
		cout << "Deriver::func3()" << endl;
	}
	virtual void func4()
	{
		cout << "Deriver::func4()" << endl;
	}
private:
	int _d;
};
int main()
{
	Base1 b1;
	Base2 b2;
	Deriver d;
	PrintVTable(*(int *)&b1);
	cout << "----------------" << endl;
	PrintVTable(*(int *)&b2);
	cout << "----------------" << endl;
	PrintVTable(*(int *)&d);
	getchar();
	return 0;
}


子类对象模型如下：

                                               

总结：

1.每个父类都有自己的虚表

2.子类的成员函数被放在第一个父类的虚函数表中

3.内存布局中，父类按照声明的顺序排列（可以将Base1与Base2的顺序调换做一下测试)


四.多重继承（有成员变量，有虚函数，有虚函数覆盖）

#include<iostream>
using namespace std;
typedef void(*FUNC)();
void PrintVTable(int p)
{
	int *ptr = (int*)p;
	FUNC fun = NULL;
	int i = 0;
	while (ptr[i])
	{
		fun = (FUNC)ptr[i];
		fun();
		i++;
	}
}
class Base1
{
public :
	Base1()
		:_b1(10)
	{}
	 virtual void func1()
	{
		cout << "Base1::func1()" << endl;
	}
	virtual void func2()
	{
		cout << "Base1::func2()" << endl;
	}
private :
	int _b1;
};
class Base2
{
public:
	Base2()
		:_b2(20)
	{}
	virtual void func1()
	{
		cout << "Base2::func1()" << endl;
	}
	virtual void func2()
	{
		cout << "Base2::func2()" << endl;
	}
private:
	int _b2;
};
class Deriver:public Base1,public Base2
{
public:
	Deriver()
		:_d(30)
	{}
	virtual void func1()
	{
		cout << "Deriver::func1()" << endl;
	}
	virtual void func3()
	{
		cout << "Deriver::func3()" << endl;
	}
	virtual void func4()
	{
		cout << "Deriver::func4()" << endl;
	}
private:
	int _d;
};
int main()
{
	Base1 b1;
	Base2 b2;
	Deriver d;
	PrintVTable(*(int *)&b1);
	cout << "----------------" << endl;
	PrintVTable(*(int *)&b2);
	cout << "----------------" << endl;
	PrintVTable(*(int *)&d);
	getchar();
	return 0;
}




从以上分析中，我们可以看出子类自己的成员函数是放在Base1的虚函数表里的，子类中重写的Deriver::func1()将Base1与Base2中的func1（）都覆盖了。

子对象模型如下：

                 

总结：

1.每个父类都有自己的虚表

2.子类的成员函数被放在第一个父类的虚函数表中

3.内存布局中，父类按照声明的顺序排列（可以将Base1与Base2的顺序调换做一下测试)

4.每个父类的func1（）都被覆盖成了子类的func1（），保证了不同父类的指针指向 同一个子类实例，实现了多态。 

五.重复继承

#include<iostream>
using namespace std;
typedef void(*FUNC)();
void PrintVTable(int p)
{
	int *ptr = (int*)p;
	FUNC fun = NULL;
	int i = 0;
	while (ptr[i])
	{
		fun = (FUNC)ptr[i];
		fun();
		i++;
	}
}
class Base
{
public :
	Base()
		:_b(10)
	{}
	 virtual void func1()
	{
		cout << "Base::func1()" << endl;
	}
	
private :
	int _b;
};
class Base1:public Base 
{
public:
	Base1()
		:_b1(20)
	{}
	virtual void func1()
	{
		cout << "Base1::func1()" << endl;
	}
	virtual void func2()
	{
		cout << "Base1::func2()" << endl;
	}
private:
	int _b1;
};
class Base2:public Base
{
public:
	Base2()
		:_b2(30)
	{}
	virtual void func1()
	{
		cout << "Base2::func1()" << endl;
	}
	virtual void func3()
	{
		cout << "Base2::func3()" << endl;
	}
private:
	int _b2;
};
class Deriver:public Base1,public Base2
{
public:
	Deriver()
		:_d(40)
	{}
	virtual void func1()
	{
		cout << "Derive::func1()" << endl;
	}

	virtual void func4()
	{
		cout << "Deriver::func4()" << endl;
	}
private:
	int _d;
};
int main()
{
	Base b;
	Base1 b1;
	Base2 b2;
	Deriver d;
	PrintVTable(*(int *)&b);
	cout << "----------------" << endl;
	PrintVTable(*(int *)&b1);
	cout << "----------------" << endl;
	PrintVTable(*(int *)&b2);
	cout << "----------------" << endl;
 	PrintVTable(*(int *)&d);

	getchar();
	return 0;


内存分布如下：


    子对象模型如下：

        

                                                   


从以上模型我们可以看出，最顶端父类的数据成员被子类Deriver继承了两次，其中一次由Base1继承而来，另一次由Base2继承而来，而子类Deriver又继承于Base1与Base2 ，所以在子对象模型中，进行如下访问时，就会产生二义性。

Deriver d;
d._b=10;//产生二义性
d.Base1::_b=10;
d.Base2::_b=10;//正确
所以在子对象模型中，_d存储了两份，造成了数据冗余，这种继承我们成为重复继承。

六.重复虚拟继承(钻石继承)

重复虚拟继承是用来解决重复继承当中所造成的数据冗余问题，当在Base1和Base2的继承方式前加上virtual就是虚拟继承。

#include<iostream>
using namespace std;
typedef void(*FUNC)();
void PrintVTable(int p)
{
	int *ptr = (int*)p;
	FUNC fun = NULL;
	int i = 0;
	while (ptr[i])
	{
		fun = (FUNC)ptr[i];
		fun();
		i++;
	}
}
class Base
{
public :
	Base()
		:_b(10)
	{}
	 virtual void func1()
	{
		cout << "Base::func1()" << endl;
	}
	
private :
	int _b;
};
class Base1:virtual public Base 
{
public:
	Base1()
		:_b1(20)
	{}
	virtual void func1()
	{
		cout << "Base1::func1()" << endl;
	}
	virtual void func2()
	{
		cout << "Base1::func2()" << endl;
	}
private:
	int _b1;
};
class Base2:virtual public Base
{
public:
	Base2()
		:_b2(30)
	{}
	virtual void func1()
	{
		cout << "Base2::func1()" << endl;
	}
	virtual void func3()
	{
		cout << "Base2::func3()" << endl;
	}
private:
	int _b2;
};
class Deriver:public Base1,public Base2
{
public:
	Deriver()
		:_d(40)
	{}
	virtual void func1()
	{
		cout << "Derive::func1()" << endl;
	}

	virtual void func4()
	{
		cout << "Deriver::func4()" << endl;
	}
private:
	int _d;
};
int main()
{
	Base b;
	Base1 b1;
	Base2 b2;
	Deriver d;
	PrintVTable(*(int *)&d);
	cout << "----------------" << endl;
	PrintVTable(*(int *)&d+3);
	cout << "----------------" << endl;
	PrintVTable(*(int *)&d+8);

	getchar();
	return 0;
}
内存布局分析如下：



                                              

                                                         

子对象模型为：

                                                                                                     


         从上面我们可以看出重复虚拟继承的时候，最顶端的父类Base是在最下面存放的,并且Base1与Base2的虚函数表中并没有Base类的成员，其依靠一个地址来寻找Base的位置。

         需要注意的是不同环境下，内存模型会有所不同，需要自己去测试，此处编译环境为vs2013。

__Lin
关注
专栏目录
C++对象模型和虚函数表分析以及重载、重写、隐藏的区别
FreeeLinux's blog
12-22 1281
C++在布局以及存取时间上主要的额外负担是由virtual引起的。包括：  Virtual function 机制 。用以支持一个有效率的“执行期绑定”（runtime binding）。  Virtual base class。用以实现“多次出现在继承体系中的base class，有一个单一而共享的实体”。  此外，还有一些多重继承下的额外负担。发生在“一个derived class
C++对象模型之虚函数
qq_40223389的博客
06-11 290
C++之虚函数 前言 本次笔记记录如下知识点 虚函数表指针位置分析 继承关系下虚函数的调用 虚函数表的分析 虚函数表指针位置分析 一个类中如果有虚函数，针对这个类会产生一个虚函数表，生成这个类对象的时候，该对象就有一个指针用来指向这个虚函数表的起始位置。 虚函数表指针位于对象内存的起始位置。 如下示例： #include <iostream> using namespace std; class A{ public: int i; virtual void fun(
深入C++对象模型&虚函数表
Sunnylunch-blog
08-25 1709
多态的实现机制：        C++中虚函数的主要作用就是用来实现多态，就是使用基类的指针或者引用调用重写的虚函数，当父类的指针或引用指向父类对象时调用的是父类虚函数，当指向子类对象时调用的是子类的虚函数。那么这又是怎么实现的呢？？？        这都是通过虚函数表实现的，虚函数表是通过一块连续内存来存储虚函数的地址。这张表解决了虚函数重写（地址进行覆盖）的问题 。在有虚函数的对象实例中都
C++对象模型之虚函数实现原理
为梦想努力向上爬的蜗牛
05-11 1156
在C++中，多态（polymorphism）的意思是，用基类的指针或者引用，寻址出一个派生类对象。而虚函数（virtual member function）是多态的基础，这也是面向对象编程迷人之处。现在刚好有时间，就写一下自己对C++在单一继承情况下如何实现虚函数的肤浅认识。 一旦一个类有一个虚函数，那么一定会建立一个虚表（virtual table），虚表里面有所有虚函数的地址。虚表是该类所有
【C++对象模型】之虚函数详解
李宁宁
11-13 538
Function语义学 Member function的各种调用方式1. Nonstatic Member Functions实际上member function被转换为nonmember function。C++设计准则就是：nonstatic member function至少必须和一般的nonmember function有相同的效率。
深度探索C++对象模型之：理解虚函数机制
菜根
05-16 854
说明：关于虚函数的基本语法知识就不再叙述，直接讲其内部原理。 （１）单继承下内存布局 举例： 类Point： class Point { public:    virtual ~Point();      virtual Point& mult( float ) = 0;     float x() const { return _x; }     //非虚函数，不作存储    v
C++虚函数表实例分析
01-21
在对象中，有一个指针指向一张虚函数表，里面按照次序存放了每一个虚函数，当子类继承的时候，即到虚函数表的指定位置去修改函数地址。当我们通过父类指针来操作一个子类的时候，调用虚函数，都是通过虚函数表+固定...
C++深度解析 C++对象模型分析（下） --- 继承对象模型，多态对象模型，虚函数表，用C语言实现多态（50）
Tim的嵌入式之旅
01-10 337
C++深度解析 C++对象模型分析（下） --- 继承对象模型，多态对象模型，虚函数表，用C语言实现多态（50）       继承对象模型 在C++编译器的内部类可以理解为结构体。 子类是由 父类成员 叠加 子类新成员 得到的。 代码如下：继承对象模型初探 #include &lt;iostream&gt; #include &lt;string&gt; using names...
C++ 学习 对象模型之虚函数
u014472011的博客
04-21 234
虚函数在C++主要用于通过父类指针调用子类对象方法，从而达到实现多态机制。虚函数声明在类中，用virtual关键字修饰，虚函数在类的定义时就被放在了内存代码段，虚函数不在对象内存布局中。 1.虚函数表与虚函数指针 虚函数表可以看作一个函数指针数组，数组里面放着类里面的所有虚函数指针，当需要调用虚函数就从这个数组里面找。在生成对象时，编译器会产生一个虚函数指针来指向虚函数表，虚函数指针在32位系统占...
C++对象模型（存在虚函数与虚继承的情况）
hexieXXX的博客
10-17 200
//C++对象模型 //存在虚函数与虚继承的情况 #include &lt;iostream&gt; using namespace std; typedef void (*FUNC)(); FUNC fun; #define PRT(x) cout&lt;&lt;x&lt;&lt;endl #define RUN(x) fun = (FUNC)x; \ fun...
虚函数表是个什么鬼？
aaa407217484的博客
08-21 124
在多重继承里的虚函数表可以在vs里面看到，如下 有一个基类就有一张表，可以通过 int** pVtab = (int**)&d; pFun = (Fun)pVtab[0][0];来访问每一个虚函数，如下代码： // pvtable1.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #i...
c++ - 虚函数表
weixin_49303682的博客
12-23 2526
1.什么是虚函数表 所谓虚函数表就是存放着当前类中所有虚函数地址的表。在实例化一个具有虚函数的类时，这个表 也被分配到这个实例对象的内存中，通过虚函数表可以指明所要调用的函数的位置。在C++编译器 中虚函数表的地址存放在对象的最前面，这是为了即使多继承下也能快速获取到虚函数表。 代码示例： class Base{ public: virtual void A(){cout << "Base::A()" << endl;} virtual void B(){cout &
【C++】虚函数表详解
Magnum的博客
03-03 266
本文转载自：https://blog.csdn.net/haoel/article/details/1948051 前言 C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技...
C++对象模型（9）-- 虚函数1
最新发布
10-17 123
虚函数的作用是允许使用基类的指针来调用子类的函数，从而实现“多态”。
C++可调用对象与函数表
weixin_34310127的博客
12-04 114
c++的可调用对象 有 函数 函数指针 lambda表达式 bind的对象 重载了函数调用运算符的类 如何调用？ 函数调用 void afuncToCall() { cout << "call me"<<"\n"; } //1.call function afuncToCall(); 函数指针调用 void func(int i){ cout &...
c++虚函数表、地址详解
papaya的博客
07-14 1555
c++虚函数表详解
C++对象模型之虚基类表和虚函数表的布局（一）
HUGOPIGS的博客
04-11 753
c++对象模型之虚基类表和虚函数表的布局（一） 注：本文的c++对象结构模型基于vs编译器的win32环境，只有microsoft编译器处理虚基类时使用虚基类表的形式，而其他编译器大多采用在虚函数表中放置虚基类的偏移量的方式。 一、虚函数表 当一个类包含一个或多个虚函数时，编译器会在他的对象中创建一个虚函数指针，这个虚函数指针指向虚函数表，虚函数表里记录者这些虚函数的地址。很多人好奇虚函数指针、虚...
【C++深度解析】34、多态与虚函数
桑凯旋的博客
02-18 350
文章目录1 函数重写回顾2 多态概念 1 函数重写回顾 父类中被重写的函数依然会继承给子类 子类中重写的函数将覆盖父类中的函数 通过作用域分辨符（::）可以访问父类中的函数 前一篇博客中我们知道，当使用父类的指针（引用）指向子类对象时，子类对象退化为父类对象，只能访问父类中的成员。也就是说父类的指针不管指向的是父类的对象还是子类的对象，调用的都是父类的函数。 2 多态概念 我们希望根据实际指向...
C++虚表详解
热门推荐
chczy1的博客
09-03 1万+
使用工具： 本文输出内存模型的工具为vs2017开发人员命令提示符，使用方法如图所示： 我们使用cl（不是C1，不是C一，是cl，LLLLL）命令cl的语法为： cl [filename].cpp /d1reportSingleClassLayout[className] 意思是查看[filename].cpp文件中名称以[className]开头的所有类的内存模型 如果文件不在同一...
C++对象模型详解：内存布局与虚表剖析
本文主要深入探讨了C++对象模型，特别是针对内存布局、虚函数表以及虚基类的实现原理。作者从C++语言层面的面向对象特性出发，引述了《深度探索C++对象模型》一书的观点，强调了C++对象模型不仅包含了面向对象编程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值