深入理解C++对象模型-对象的内存布局,vptr,vtable

最新推荐文章于 2024-11-18 13:37:01 发布
转载 最新推荐文章于 2024-11-18 13:37:01 发布 · 1.5k 阅读 · 0

本文深入探讨了C++中虚函数和vtable的内存布局，通过代码实例详细展示了不同继承情况下的内存分配特点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

vtpr的位置:
       为了支持多态,C++引入了vtpr和vtable这两个概念.对于每个有虚函数的类,C++都会为其生成一个vtable,并在类中添加一个隐含的数据成员vptr. 对于vptr在对象中的位置,跟类的数据成员的布局一样,C++标准里面并没有做出任何的规定.但是对于特定的编译器,我们还是可以通过研究C++对象的内存布局来确定vtpr到底是放在哪里.
      下面我们通过分析C++对象的内存布局,来寻找vptr的位置.在开始讨论之前我们先提供一个模板函数void PrintLayout(T const & obj),该函数用于打印obj所在内存的内容,下面是该函数的实现:


PrintLayout.hxx

#pragma once
#include <iostream>
#include <iomanip>
#include <ReinterpretCast.hxx>

template<typename T>
void PrintLayout(T const & obj)
{
	int * pObj = ReinterpretCast<int*>(&obj);
	for (int i =0; i<sizeof(obj)/sizeof(int);++i)
	{
		std::cout<<std::setw(10)<< pObj[i]<<std::endl;
	}
}


接下来通过代码来分析一下在C++里,在没有继承,单继承,多继承以及虚继承等情况下对象的内存布局,下面是示例代码,为了减少代码量,我们将类的所有数据成员设为public的,在这里我们用struct来代替class:



//main.cpp

#include <iostream>
#include <PrintLayout.hxx>
#include <typeinfo>
using namespace std;

struct NoVirtualMemFunc
{
	int  Func1(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int  Func2(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};
struct Base1
{
	virtual int  Base1Func1(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	virtual int  Base1Func2(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};
struct Base2
{
	virtual int  Base2Func1(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	virtual int  Base2Func2(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};

struct D1:public Base1
{
	virtual int  D1Func(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};
struct D:public Base1,public Base2
{
	virtual int  DFunc(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};

struct VD1:public virtual Base1
{
	virtual int  VD1Func(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};
struct VD2:public virtual Base1
{
	virtual int  D2Func(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};
struct VD:public VD1,public VD2
{
	int m_iData;
};



template<typename T>
void PRINT_LAYOUT(T const & obj)
{
	cout<<"The layout of "<<typeid(obj).name()<<"----------------"<<endl;
	PrintLayout(obj);
	cout<<endl;
}
int main(int argc, char* argv[])
{
	//没有继承,没有虚函数的情况
	{
		NoVirtualMemFunc obj;
		obj.m_iData = 100;
		PRINT_LAYOUT(obj);
	}
	

	//没有继承,有虚函数的情况
	{
		Base1 obj;
		obj.m_iData = 100;
		PRINT_LAYOUT(obj);
	}
	

	//单继承
	{
		D1 obj;
		obj.Base1::m_iData = 100;
		obj.m_iData = 200;
		PRINT_LAYOUT(obj);
	}
	

	//多继承
	{
		D obj;
		obj.Base1::m_iData  = 100;
		obj.Base2::m_iData  = 200;
		obj.m_iData = 300;
		PRINT_LAYOUT(obj);
	}
	

	//虚拟继承
	{
		VD1 obj;
		obj.Base1::m_iData = 100;
		obj.m_iData = 200;
		PRINT_LAYOUT(obj);
	}
	

	//棱形继承
	{
		VD obj;
		obj.Base1::m_iData = 100;
		obj.VD1::m_iData   = 200;
		obj.VD2::m_iData   = 300;
		obj.m_iData       = 500;
		PRINT_LAYOUT(obj);

	}
	return 0;
}

//输出
/*
The layout of struct NoVirtualMemFunc----------------
      100

The layout of struct Base1----------------
   4294656
       100

The layout of struct D1----------------
   4294740
       100
       200

The layout of struct D----------------
   4294800
       100
   4294776
       200
       300

The layout of struct VD1----------------
   4294876
   4294888
       200
   4294864
       100

The layout of struct VD----------------
   4294944
   4294968
       200
   4294932
   4294952
       300
       500
   4294920
       100

请按任意键继续. . .



对于有虚表的函数,从上面的输出我们可以得到以下结论,

1.没有继承情况,vptr存放在对象的开始位置,以下是Base1的内存布局

vptr : 4294656

m_iData :100


 2.单继承的情况下,对象只有一个vptr,它存放在对象的开始位置,派生类子对象在父类子对象的最后面,以下是D1的内存布局

vptr : 4294740

B1:: m_iData : 100

B2:: m_iData :200


3.多继承情况下,对象会为每个有虚函数的父类子对象提供一个vptr,派生类子对象在所有父类子对象的最后面,所有父类子对象按照声明顺序排列,以下是D的内存布局

B1::vptr : 4294800

B1::m_iData :100

B2::vptr : 4294776

B2::m_iData :200

D::m_iData :300


4. 虚拟继承情况下,虚父类子对象会放在派生类子对象之后,派生类子对象的第一个位置存放着一个vptr,虚拟子类子对象也会保存一个vptr,以下是VD1的内存布局

VD1::vptr :4294876

 Unknown : 4294888

VD1::m_iData : 200

B1::vptr :4294864

B1::m_iData :100


5. 棱形继承的情况下,非虚基类子对象在派生类子对象前面,并按照声明顺序排列,虚基类子对象在派生类子对象后面

VD1::vptr :        4294944

VD1::Unknown : 4294968

VD1::m_iData :  200

VD2::vptr :    4   294932

VD2::Unknown : 4294952

VD2::m_iData : 300

VD::m_iData : 500

B1::vptr :       4294920

B1::m_iData :  100


接下来我们将通过代码来验证前面结论的准确性.下面的代码具有一定的局限性.在调试以下代码的时候,对虚拟继承遇到了以下几个让我迷惑的问题:

1.对于虚拟继承,函数指针的大小为12

2.用vtable里面的指针调用,this不能正确传进去

3.如果派生类的虚拟函数多于1个,则会crash

 

//main.cpp

#include <iostream>
#include <GetVptr.hxx>
#include <typeinfo>
using namespace std;

struct NoVirtualMemFunc
{
	int  Func1(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int  Func2(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};
struct Base1
{
	virtual int  Base1Func1(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	virtual int  Base1Func2(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};
struct Base2
{
	virtual int  Base2Func1(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	virtual int  Base2Func2(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};

struct D1:public Base1
{
	virtual int  D1Func(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};
struct D:public Base1,public Base2
{
	virtual int  DFunc(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};

struct VD1:public virtual Base1
{
	virtual int  VD1Func(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};
struct VD2:public virtual Base1
{
	virtual int  D2Func(int a,int b){
		cout<<__FUNCTION__<<"/tm_iData="<<m_iData<<"/ta="<<a<<"/tb="<<b<<endl;
		return 0;
	}
	int m_iData;
};
struct VD:public VD1,public VD2
{
	int m_iData;
};

template<class T>
struct MemFuncT
{
	typedef int (T::* T_MemFuncT)(int,int);
	typedef int (T::* T_MemDataT);
};
template<class C>
void CallMemFunc(int iFuncNum,int (C::**vptr)(int,int),C& obj,int a =500,int b =600)
{
	for (int i =0;i<iFuncNum;++i)
	{
		//cout<<ReinterpretCast<void*>(vptr[i])<<"   ";
		(obj.*vptr[i])(a,b);
	}
	cout<<endl;
}
int main(int argc, char* argv[])
{


	//没有继承,有虚函数的情况
	{
		cout<<"//没有继承,有虚函数的情况"<<endl;
		Base1 obj;
		obj.m_iData = 100;
		MemFuncT<Base1>::T_MemFuncT * vptr = ReinterpretCast<MemFuncT<Base1>::T_MemFuncT *>(GetVptr(obj));
		CallMemFunc(2,vptr,obj);
	}
	

	//单继承
	{
		cout<<"//单继承"<<endl;
		D1 obj;
		obj.Base1::m_iData = 100;
		obj.m_iData = 200;
		MemFuncT<D1>::T_MemFuncT * vptr = ReinterpretCast<MemFuncT<D1>::T_MemFuncT *>(GetVptr(obj));
		CallMemFunc(3,vptr,obj);
	}
	

	//多继承
	{
		cout<<"//多继承"<<endl;
		D obj;
		obj.Base1::m_iData  = 100;
		obj.Base2::m_iData  = 200;
		obj.m_iData = 300;

		Base1 &objB1 = obj;
		MemFuncT<Base1>::T_MemFuncT * vptr = ReinterpretCast<MemFuncT<Base1>::T_MemFuncT *>(GetVptr(obj));
		CallMemFunc(3,vptr,objB1);

		Base2 &objB2 = obj;
		MemFuncT<Base2>::T_MemFuncT * vptrB2 = ReinterpretCast<MemFuncT<Base2>::T_MemFuncT *>(GetVptr(objB2));
		CallMemFunc(2,vptrB2,objB2);
	}
	
#if 1
	//虚拟继承
	{
		cout<<"//虚拟继承"<<endl;
		VD1 obj;
		obj.Base1::m_iData = 100;
		obj.m_iData = 200;
		MemFuncT<VD1>::T_MemFuncT * vptr = ReinterpretCast<MemFuncT<VD1>::T_MemFuncT *>(GetVptr(obj));
		CallMemFunc(1,vptr,obj);

		Base1 & objB1 =obj ;
		MemFuncT<Base1>::T_MemFuncT * vptrB1 = ReinterpretCast<MemFuncT<Base1>::T_MemFuncT *>(GetVptr(objB1));
		CallMemFunc(2,vptrB1,objB1);
	}
	

	//棱形继承
	{
		cout<<"//棱形继承"<<endl;
		VD obj;
		obj.Base1::m_iData = 100;
		obj.VD1::m_iData   = 200;
		obj.VD2::m_iData   = 300;
		obj.m_iData       = 500;

		Base1 & objB1 = obj;
		MemFuncT<Base1>::T_MemFuncT * vptrB1 = ReinterpretCast<MemFuncT<Base1>::T_MemFuncT *>(GetVptr(objB1));
		CallMemFunc(2,vptrB1,objB1);

		VD1   & objVD1 =obj;
		MemFuncT<VD1>::T_MemFuncT * vptrVD1 = ReinterpretCast<MemFuncT<VD1>::T_MemFuncT *>(GetVptr(objVD1));
		CallMemFunc(1,vptrVD1,objVD1);

		VD2   & objVD2 =obj;
		MemFuncT<VD2>::T_MemFuncT * vptrVD2 = ReinterpretCast<MemFuncT<VD2>::T_MemFuncT *>(GetVptr(objVD2));
		//CallMemFunc(1,vptrVD2,objVD2);
	}
#endif
	return 0;
}

//输出
/*
//没有继承,有虚函数的情况
Base1::Base1Func1       m_iData=100     a=500   b=600
Base1::Base1Func2       m_iData=100     a=500   b=600

//单继承
Base1::Base1Func1       m_iData=100     a=500   b=600
Base1::Base1Func2       m_iData=100     a=500   b=600
D1::D1Func      m_iData=200     a=500   b=600

//多继承
Base1::Base1Func1       m_iData=100     a=500   b=600
Base1::Base1Func2       m_iData=100     a=500   b=600
D::DFunc        m_iData=300     a=500   b=600

Base2::Base2Func1       m_iData=200     a=500   b=600
Base2::Base2Func2       m_iData=200     a=500   b=600

//虚拟继承
VD1::VD1Func    m_iData=4294960 a=500   b=600

Base1::Base1Func1       m_iData=100     a=500   b=600
Base1::Base1Func2       m_iData=100     a=500   b=600

//棱形继承
Base1::Base1Func1       m_iData=100     a=500   b=600
Base1::Base1Func2       m_iData=100     a=500   b=600

VD1::VD1Func    m_iData=4295032 a=500   b=600

请按任意键继续. . .
*/




猫山王
关注
Vtable内存布局分析
m0_37595954的博客
10-22 834
vtale 内存布局分析 虚函数表指针与虚函数表布局 考虑如下的 class： class A { public: int a; virtual void f1() {} virtual void f2() {} }; int main() { A *a1 = new A(); return 0; } 首先明确，sizeof(A)的输...
深入理解C++对象模型--虚拟继承(1)
qls315的博客
05-26 880
0 引言 最近在工作之余，重新拾起了深度探索C++对象模型这本书，想要进一步复习理解 C++对象模型相关的原理。 以往看这本书，仅仅是浮于表面，并没有动手去实现和验证书中所说的内容。因此这次，便想既然再度学习，那么就深入去看一看目前流行的编译器对C++对象模型 是如何实现的。故有了本专题。 目前使用较广泛的编译器有gcc，clang， msvc，但作为C++后台开发相信使用gcc，clang较多，而我也是使用两者较多，因此本专题中以gcc编译器为主，主要深入研究其对C++对象模型的实现。 如果你..
图说C++对象模型：对象内存布局详解
SimonxxSun的博客
05-14 430
目录 1.何为C++对象模型? 2.文章内容简介 3.理解虚函数表 3.1.多态与虚表 3.2.使用指针访问虚表 4.对象模型概述 4.1.简单对象模型 4.2.表格驱动模型 4.3.非继承下的C++对象模型 5.继承下的C++对象模型 5.1.单继承 5.2.多继承 5.2.1一般的多重继承（非菱形继承） 5.2.2 菱形继承 6.虚继承 6.1.虚基类表解析 ...
C++对象模型4——多重继承的对象内存模型、vptr与vtbl的创建与重置的时机、不要在含有虚函数的类的构造函数中调用memset
Master Cui的博客
03-18 755
一、多重继承的对象内存模型 class Base1 { public: virtual void f() { cout << "base1::f()" << endl; } virtual void g() { cout << "base1::g()" << endl; } }; class Base2 { public: virtual void h() { cout << "base2::h()" <<
C++ 对象内存布局详解
好记性不如写博客！
10-29 271
阅读目录 0.前言 1.何为C++对象模型? 2.文章内容简介 3.理解虚函数表 3.1.多态与虚表 3.2.使用指针访问虚表 4.对象模型概述 4.1.简单对象模型 4.2.表格驱动模型 4.3.非继承下的C++对象模型 5.继承下的C++对象模型 5.1.单继承 5.2.多继承 6.虚继承 6.1.虚基类表解析 6.2.简单虚继承 6....
图说C++对象模型.pdf
07-31
综上所述，C++对象模型的深入理解，包括其内存布局、虚表指针、虚基类指针等，对于开发高性能的C++程序是必不可少的。尽管相关的知识可能比较复杂且枯燥，但掌握它们对于提升编程技能和解决实际问题非常有益。由于...
深入理解C++对象模型与内存管理
深入理解C++对象模型，对于任何一个想要提高自己编程技能的开发者来说都是至关重要的。 首先，我们来讨论C++对象内存模式。C++对象内存模式涉及几个关键概念：对象布局(object layout)、虚函数表(virtual table, ...
深入理解C++对象模型
了解C++对象模型对于深入理解C++语言的特性以及编写高效的代码是至关重要的。 ### 知识点详细说明： #### 1. 对象模型基础 - **对象内存布局**：C++编译器会为每个类生成一个对象模型，这个模型定义了类的实例...
深入理解C++对象模型的机制
C++的对象模型主要分为以下几个部分：对象内存布局（Object Memory Layout）、构造函数和析构函数、虚函数机制、模板、异常处理等。这些主题直接关系到C++程序的效率和运行时行为。 首先，对象内存布局是指在内存中...
C++对象模型3——vptr的位置、手动调用虚函数、从汇编代码看普通调用和多态调用
Master Cui的博客
03-18 938
一、vptr的位置 class test { public: int i; virtual void testfunc() {} }; int main() { test a; char* p1 = reinterpret_cast<char*>(&a); char* p2 = reinterpret_cast<char*>(&(a.i)); if (p1 == p2) { //如果a.i和a的地址相同，则成员变量i在a对
c++ vtable 深入解析
fcsfcsfcs的博客
05-04 5445
c++ 利用虚函数实现了多态的能力，虚函数涉及到虚指针和虚表，本文将从汇编和虚表深入探索虚函数机制。 【之前写过关于 vtable 的分为上下两篇文章，但发现并不好懂，且有一些疏漏的地方，本着要对写出来的东西负责任的态度，所以修改了文章，并整合为一篇。】 refer https://www.tuicool.com/articles/iUB3Ebi 1、环境 x86_64-apple-macos10.15 Apple clang version 11.0.0 注：不同环境下不同编译器，对于虚表
C++对象模型浅析
weixin_34075551的博客
01-07 224
该文章转自阿里巴巴技术协会（ata）作者：霜天 VTable 虚表 虚表的内存分布 一个简单的包含虚函数的类的声明 class A { public: virtual void v_a(){} virtual ~A(){} int64_t _m_a; }; /***********************/ int mai...
dynamic_cast背着你偷偷做了什么
D_Guco的专栏
05-10 1088
c++常用的四中转换类型我们都很清楚，分别是下面四中 　 １const_cast　 const_cast<目标类型>（标识符）:目标类型只能是指针或者引用2static_cast 类似C风格的强制转换，进行无条件转换，静态类型转换： 1）基类和子类之间的转换：其中子类指针转换为父类指针是安全的，但父类指针转换为子类指针是不安全的（基类和子类之间的动态类型转换建议用dynamic_cast）。 2）基本数据类型转换，enum，struct，int，char，float等。static_cast
C++虚函数表(vtable)和虚函数指针(vfptr)
一首小夜曲
01-23 7302
编译器会构建一张虚表（ vtable )，每一个类都有自己独特的虚表。同时，在这个继承链上，编译器会为基类插入一个隐式的指针（一般是对象的首地址），指向虚表，称为__vptr。然后，子类继承父类时，会获得继承下来的__vptr，再根据自己的类的情况兼容（修改虚函数表里的值、发生偏移等。于是，当我们构建具体的类时，若是基类类型，__vptr就会指向父类的vtable，若是子类类型，__vptr就会指
对《深入C++对象模型》中的一个疑问——虚函数表的type_info的位置
CoderJeff的博客
06-18 4632
vptr指向的第一个位置是第一个虚函数的地址，不是type_info
C++ RTTI 机制下判断类型的 typeid 和记录类型信息的 type_info
竹剑单
06-04 1385
RTTI RTTI（RunTime Type Identification），运行时类型识别。C++ 是允许在程序运行过程中，根据指针和引用的实际类型来决定执行方法的（动态多态）。因为运行时变量声明的类型和实际的类型可能不一样，所以就有了RTTI。RTTI包含两个内容：typeid 和 dynamic_cast。typeid 用来确定目标的实际类型是什么。dynamic_cast 用于基类向派生类的向下转型。 typeid 用于判断目标类型。typeid(n)，参数n可以是类型、变量、字面量等，typeid
C++的虚函数表（vtable）剖析
最新发布
qq_63871189的博客
11-18 404
虚函数表（vtable）是一种用于实现多态性的机制，常见于 C++ 等面向对象编程语言中。
C++对象模型 学习笔记
icky的博客
06-18 373
对于《深度C++对象模型》一书的学习总结，从对象、数据、函数三块进行分析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值