C++ 对象的内存布局—— 虚继承下的虚函数

最新推荐文章于 2023-02-16 22:43:59 发布
置顶 最新推荐文章于 2023-02-16 22:43:59 发布
阅读量1.1k 收藏 2
点赞数 1
CC 4.0 BY-SA版权
文章标签： 虚继承 虚函数 类内存布局
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u013071074/article/details/38680059
本文探讨了 C++ 中虚拟继承和钻石继承情况下类的内存布局。通过 VS2005 查看 B1 类及 D 类的内存分布，并分析了虚函数表和虚基类指针的具体指向。

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

C++ 对象的内存布局(下)这篇文章的“单一虚拟继承”和“钻石型虚拟继承”时的类内存布局讲得不太清楚，我有一处疑问，我用的是VS2005，因此记录一下。

 

类继承图如下：


这里：类B被类B1和B2虚拟继承，而B1和B2同时被D继承。
B1的f()、B2的f()覆盖了B的f()；
D的f()覆盖了B1的f(),D的f1()覆盖了B1的f1()
D的f()覆盖了B2的f(),D的f2()覆盖了B2的f2()

类代码如下：

class B
{
    public:
        int ib;
        char cb;
    public:
        B():ib(0),cb('B') {}
 
        virtual void f() { cout << "B::f()" << endl;}
        virtual void Bf() { cout << "B::Bf()" << endl;}
};
class B1 :  virtual public B//虚拟继承，钻石型继承
{
    public:
        int ib1;
        char cb1;
    public:
        B1():ib1(11),cb1('1') {}
 
        virtual void f() { cout << "B1::f()" << endl;}
        virtual void f1() { cout << "B1::f1()" << endl;}
        virtual void Bf1() { cout << "B1::Bf1()" << endl;}
 
};
class B2:  virtual public B
{
    public:
        int ib2;
        char cb2;
    public:
        B2():ib2(12),cb2('2') {}
 
        virtual void f() { cout << "B2::f()" << endl;}
        virtual void f2() { cout << "B2::f2()" << endl;}
        virtual void Bf2() { cout << "B2::Bf2()" << endl;}
       
};
 
class D : public B1, public B2
{
    public:
        int id;
        char cd;
    public:
        D():id(100),cd('D') {}
 
		virtual void f() { cout << "D::f()" << endl;}
		virtual void f1() { cout << "D::f1()" << endl;}
        virtual void f2() { cout << "D::f2()" << endl;}
        virtual void Df() { cout << "D::Df()" << endl;}
};

（1）单一虚拟继承：B1虚拟继承自B

查看类B1的内存布局的代码如下：

{
	int** pVtab = NULL;
	Fun pFun = NULL;

	B1 bb1;

	pVtab = (int**)&bb1;

	cout << "sizeof(B1) = " << sizeof(B1) << endl;

	cout << "[0] B1::_vfptr->" << endl;
	for (int i = 0; ; i++)
	{
		pFun = (Fun)pVtab[0][i];
		cout << '\t' << "[" << i << "] 0x" << (int*)pFun << "\t";
		if (pFun == NULL)
		{
			cout << endl;
			break;
		}
		pFun();
	}

	cout << "[1] B1::_vbptr->" << endl;
	cout << "\t" << "[0] B1dB1bptrB1 " << pVtab[1][0] << endl;
	cout << "\t" << "[1] B1dB1bptrB " << pVtab[1][1] << endl;

	cout << "[2] B1::ib1 = " << (int)pVtab[2] << endl;
	cout << "[3] B1::cb1 = " << (char)pVtab[3] << endl;

	cout << "[4] = 0x" << (int*)pVtab[4]/*[0]*/ << endl;

	cout << "[5] B::_vfptr->" << endl;	//
	cout << '\t' << "[" << 0 << "] thunk = 0x" << (int*)pVtab[5][0] << endl;
	for (int i = 1; ; i++)
	{
		pFun = (Fun)pVtab[5][i];
		cout << '\t' << "[" << i << "] 0x" << (int*)pFun << "\t";
		if (pFun == NULL)
		{
			cout << endl;
			break;
		}
		pFun();
	}
	
	cout << "[6] B::ib = " << (int)pVtab[6] << endl;
	cout << "[7] B::ic = " << (char)pVtab[7] << endl;
}

代码输出了类B1的布局：

sizeof(B1) = 32
[0] B1::_vfptr->
        [0] 0x0041106E  B1::f1()
        [1] 0x004110AF  B1::Bf1()
        [2] 0x00000000
[1] B1::_vbptr->
        [0] B1dB1bptrB1 -4
        [1] B1dB1bptrB 16
[2] B1::ib1 = 11
[3] B1::ic1 = 1
[4] = 0x00000000     //VC++中的一个NULL分隔符把B和B1的布局分开
[5] B::_vfptr->
        [0] 0x00411055  //奇怪的地方：这个不是函数B1::f()的地址，因为执行这个地址的函数会出错，那么整个B1类的B1::f()虚函数在哪里呢？难道是“调整块”的地址？
        [1] 0x004111F4  B::Bf()
        [2] 0x00000000
[6] B::ib = 0
[7] B::ic = B


（2）钻石型虚拟继承

查看类D的内存布局的代码如下：

{
	int** pVtab = NULL;
	Fun pFun = NULL;

	D d;

	pVtab = (int**)&d;

	cout << "sizeof(D) = " << sizeof(D) << endl;
	
	cout << "[0] D::B1::_vfptr->" << endl;
	for (int i = 0; ; i++)
	{
		pFun = (Fun)pVtab[0][i];
		cout << '\t' << "[" << i << "] 0x" << (int*)pFun << "\t";
		if (pFun == NULL)
		{
			cout << endl;
			break;
		}
		pFun();
	}

	cout << "[1] D::B1::_vbptr->" << endl;
	cout << "\t" << "[0] DdB1bptrB1 " << pVtab[1][0] << endl;
	cout << "\t" << "[1] DdB1bptrB " << pVtab[1][1] << endl;

	cout << "[2] B1::ib1 = " << (int)pVtab[2] << endl;
	cout << "[3] B1::cb1 = " << (char)pVtab[3] << endl;

	cout << "[4] D::B2::_vfptr->" << endl;
	for (int i = 0; ; i++)
	{
		pFun = (Fun)pVtab[4][i];
		cout << '\t' << "[" << i << "] 0x" << (int*)pFun << "\t";
		if (pFun == NULL)
		{
			cout << endl;
			break;
		}
		pFun();
	}

	cout << "[5] D::B2::_vbptr->" << endl;
	cout << "\t" << "[0] DdB2bptrB2 " << pVtab[5][0] << endl;
	cout << "\t" << "[1] DdB1bptrB " << pVtab[5][1] << endl;

	cout << "[6] B2::ib2 = " << (int)pVtab[6] << endl;
	cout << "[7] B2::cb2 = " << (char)pVtab[7] << endl;

	cout << "[8] D::id = " << (int)pVtab[8] << endl;
	cout << "[9] D::cd = " << (char)pVtab[9] << endl;

	cout << "[10] = 0x" << (int*)pVtab[10]/*[0]*/ << endl;

	cout << "[11] D::B::_vfptr->" << endl;

	cout << '\t' << "[" << 0 << "] 0x" << (int*)pVtab[11][0] << endl;//奇怪的地方
	for (int i = 1; ; i++)
	{
		pFun = (Fun)pVtab[11][i];
		cout << '\t' << "[" << i << "] 0x" << (int*)pFun << "\t";
		if (pFun == NULL)
		{
			cout << endl;
			break;
		}
		pFun();
	}

	cout << "[12] B::ib = " << (int)pVtab[12] << endl;
	cout << "[13] B::ic = " << (char)pVtab[13] << endl;
}

 代码输出了类D的布局：

sizeof(D) = 56
[0] D::B1::_vfptr->
        [0] 0x00411163  D::f1()
        [1] 0x004110AF  B1::Bf1()
        [2] 0x004110D2  D::Df()
        [3] 0x00000000
[1] D::B1::_vbptr->
        [0] DdB1bptrB1 -4
        [1] DdB1bptrB 40
[2] B1::ib1 = 11
[3] B1::cb1 = 1
[4] D::B2::_vfptr->
        [0] 0x0041101E  D::f2()
        [1] 0x00411159  B2::Bf2()
        [2] 0x00000000
[5] D::B2::_vbptr->
        [0] DdB2bptrB2 -4
        [1] DdB1bptrB 24
[6] B2::ib2 = 12
[7] B2::cb2 = 2
[8] D::id = 100
[9] D::cd = D
[10] = 0x00000000   //VC++中的一个NULL分隔符把B和B1和B2的布局分开
[11] D::B::_vfptr->
        [0] 0x004110C3    //奇怪的地方：这个不是函数D::f()的地址，因为执行这个地址的函数会出错，那么整个D类的D::f()虚函数在哪里呢？难道是“调整块”的地址？
        [1] 0x004111F4  B::Bf()
        [2] 0x00000000
[12] B::ib = 0
[13] B::cb = B


目前我还不清楚是怎么回事，不知道是不是thunk之类的原因。

参考：C++ 对象的内存布局(下)

u013071074
关注
[C++基础]对象内存分布--虚继承
超越
03-26 829
virtual在C++中最大的功能就是声明虚函数和虚基类。虚拟继承是为了解决多重继承下公共基类的多份拷贝问题。 虚继承 虚继承解决了菱形继承中对派生类拥有多个间接父类实例的情况。虚继承的派生类的内存布局与普通继承很多不同，主要体现在： 虚继承的子类，如果本身定义了新的虚函数，则编译器为其生成一个虚函数指针（vptr）以及一张虚函数表。该vptr位于对象内存最前面。vs非虚继承：直接扩展父类虚...
C++之对象内存布局（继承、虚函数、虚继承等多种情况）
Keep trying until you get it right
04-10 466
目录 1. 对象内存布局基本情况 2. 在不同情况下的对象内存布局——通过实验验证 2.1 无继承 2.1.1 无虚函数 2.1.2 有虚函数 2.2 深度为1的多继承 2.2.1 无虚函数 1. 对象内存布局基本情况 （1）对象内存空间中存放的内容包括普通成员变量、虚表指针（如果类中包含虚函数）、虚基表指针（如果存在虚继承）； （2）对象内存空间大小按结构体对齐原则来计算，若类是空类，则对象内存空间大小是1字节，以保证不同对象的内存地址不同；当空类作为基类时，对于派生类来说，其基类部分
C++虚继承中的对象内存布局
weixin_34146410的博客
03-09 166
钻石型虚拟继承虚继承是为了解决多继承中的数据冗余而出现的。eg：#define_CRT_SECURE_NO_WARNINGS1 #include<iostream> usingnamespacestd; typedefvoid(*FUNC)(); classBase { public: virtualvoidfun1() { cou...
c++虚继承对象的内存布局
09-13 284
备注：转载于http://blog.youkuaiyun.com/BlueDog/article/details/4711169 网上关于c++对象布局的文章挺多，而且《深度探索c++对象模型》(Inside The C++ Object Model 侯捷译）一书中也很详细地介绍。
C++ 多态与虚函数表（四）—— 虚继承
行走
08-16 411
一、前言 个人笔记，不保证严谨和正确☺，如有错误还望指出！ 《C++ 多态与虚函数表（一）—— 单继承》 《C++ 多态与虚函数表（二）—— 多继承》 《C++ 多态与虚函数表（三）—— 重复继承》 《C++ 多态与虚函数表（四）—— 虚继承》 《C++ 多态与虚函数表（五）拓展—— 对象大小》 二、单虚继承Base1 只有一层继承关系且为虚继承，只是用于测试，实际工作中不会这么样。 2.1 类定义 class Base { public: long long ibase.
C++多态篇2——虚函数表详解之从内存布局看函数重载，函数覆盖，函数隐藏
lixungogogo的博客
04-15 7566
上一篇C++多态篇1一静态联编，动态联编、虚函数与虚函数表vtable中，我在最后分析了虚函数与虚函数表的内存布局，在下一篇详细剖析虚函数及虚函数表的过程中，我发现有关函数重载，函数覆盖，函数重写和函数协变的知识也要理解清楚才能对虚函数表在内存中的布局，对派生类的对象模型以及对多态的实现有更深的理解。 所以这一篇我作为一篇过渡篇，也同时对我以前写过的一篇博文进行一个收尾。在C++继承详解
深度解析C++中的虚函数与多态：实现原理与应用场景
最新发布
03-25
最后讲解了几类典型的虚函数使用问题，包括析构函数应当设置为虚的原因、构造函数不应设定成虚的原则、以及多继承时的虚函数表布局等。 适用人群：具有一定C++编程经验，希望通过理论结合案例加深对虚函数和多态概念...
C++继承详解之三——菱形继承+虚继承内存对象模型详解vbptr（1）
lixungogogo的博客
04-12 9338
在我个人学习继承的过程中，在网上查阅了许多资料，这些资料中有关菱形继承的知识都是加了虚函数的，也就是涉及了多态的问题，而我在那个时候并没有学习到多态这一块，所以看很多资料都是云里雾里的，那么这篇文章我想以我自己学习过程中的经验，由简到较难的先分析以下菱形继承，让初学者先对这个问题有一点概念，在后面会由浅入深的继续剖析。 本篇文章不会涉及到多态也就是虚函数的菱形继承，在后面的文章更新中，我
C++ 内存布局虚继承 ---Empty virtual base classs (空虚基类)
12-16
C++ 内存布局虚继承 ---Empty virtual base classs (空虚基类).doc
虚函数和虚继承及其在内存中布局
08-03
该资源为虚函数和虚继承及其结合的内存布局的测试，文中写明了有详细测试结果。
C++虚继承内存布局
weixin_38255385的博客
02-16 567
虚继承
C++中虚继承的内存布局
weixin_30556161的博客
08-06 133
看了 《Inside c++ object model》 想到一个题目： #include <iostream>using namespace std;class A{virtual void f(){};};class B : public virtual A{ virtual void f(){};};class C: public virtual A{v...
C++虚继承时内存布局
T.liu
10-22 437
http://wenku.baidu.com/view/a516063567ec102de2bd894f.html http://wenku.baidu.com/view/fb5528345a8102d276a22f3e.html
c++内存分布（二）--虚函数和虚继承
anhkgg的专栏
08-10 1576
c++内存分布（二）--虚函数和虚继承 http://hi.baidu.com/kuhntoria/blog/item/5872c1fe9bfd5d0d6d22eb22.html 2011-08-31 16:20 一．多重继承 首先我们先来考虑一个很简单(non-virtual)的多重继承。看看下面这个C++类层次结构。 1 class Top 2 { 3 pub
C++ 虚函数/虚继承内存布局
路漫漫其修远兮
07-17 694
1 前言 1.1 多态 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 多态分为静态多态和动态多态。 （1）静态多态：是发生在编译期，是一种早绑定。通过函数重载和泛型编程实现。 （2）动态多态：是发生在运行期，是一种晚绑定。通过虚函数实现。 注意以下函数不能是虚函数： （1）普通函数（非类成员函数） （2）静态函数 ...
C++ 虚继承以及内存布局
刘国元的专栏
06-11 700
文章目录什么时候用到虚继承虚基类的初始化虚基类的成员调用几种虚继承虚继承与访问控制的关系几个问题看一个例子，观察虚继承对象内存结构reference 本篇源码部分来自clang，部分来自《C++程序设计语言 4th》的21章。 本篇是在学/复习虚继承的相关概念，发现这个一般用不到的概念还是有很多东西没有理解了的。 什么时候用到虚继承 有的时候，在类设计上，将数据、接口放在了基类中，就可能会产生了菱形继承结构。比如： class Storable { public: Storable(const st
虚继承内存布局@c++对象模型
飞鸟
08-31 783
在c++对象模型中，如果子类虚继承父类，内存布局 。
C++虚函数详解：内存布局与实现机制
总结来说，C++的虚函数实现涉及动态链接表——虚函数表，它使得子类对象能够根据实际类型调用正确的函数，即便通过基类指针。理解内存布局对于调试和优化C++程序至关重要，尤其是处理多态行为时。通过这个实例，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值