C++对象模型分析

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

class 是一种特殊的 struct

在内存中 class 依旧可以看作变量的集合

class 和 struct 遵循相同的内存对齐原则

class 中的成员函数和成员变量是分开存放的

  • 每个对象有独立的成员变量
  • 所有对象共享类中的成员函数

值得思考的问题

对象内存布局初探

#include <iostream>
#include <string>

using namespace std;

class A
{
    int i;
    int j;
    char c;
    double d;
public:
    void print()
    {
        cout << "i = " << i << ", "
             << "j = " << j << ", "
             << "c = " << c << ", "
             << "d = " << d << endl;
    }
};

struct B
{
    int i;
    int j;
    char c;
    double d;
};

int main()
{
    A a;
    
    cout << "sizeof(A) = " << sizeof(A) << endl;    // 24 bytes
    cout << "sizeof(a) = " << sizeof(a) << endl;
    cout << "sizeof(B) = " << sizeof(B) << endl;    // 24 bytes
    
    a.print();
    
    B* p = reinterpret_cast<B*>(&a);
    
    p->i = 1;
    p->j = 2;
    p->c = 'c';
    p->d = 3;
    
    a.print();
    
    p->i = 100;
    p->j = 200;
    p->c = 'C';
    p->d = 3.14;
    
    a.print();
    
    return 0;
}

上面的代码中定义了 class A 和 struct B，class A 和 struct B 具有相同的成员变量，class A 多了一个 print 函数

第 34 行 - 36 行，打印 class A 和 struct B 所占用的内存空间

第 40 行，将 class A 类型强转为 struct B，然后对里面的成员变量进行赋值，看 class 和 struct 内存布局是否一致

程序运行结果如下图所示：

通过打印可以看出成员函数不占据类的存储空间，具有相同成员变量的 class 和 struct 在内存空间中排布位置是一样的，遵循相同的内存对齐原则。所占用的内存空间是一样的。通过强制类型转换，我们对 class A 里 private 访问权限的成员变量的值进行了修改，说明了访问权限关键字在运行的时候无效

运行时的对象退化为结构体的形式

所有成员变量在内存中依次排布

成员变量间可能存在内存间隙

可以通过内存地址直接访问成员变量

访问权限关键字在运行时失效

类中的成员函数位于代码段中

调用成员函数时对象地址作为参数隐式传递

成员函数通过对象地址访问成员变量

C++ 语法隐藏了对象地址的传递过程

对象本质分析

demo.h

#ifndef __DEMO_H
#define __DEMO_H

typedef void Demo; 

Demo* Demo_Create(int i, int j);
int Demo_GetI(Demo* d);
int Demo_GetJ(Demo* d);
int Demo_Add(Demo* d, int value);
void Demo_Free(Demo* d);

#endif

demo.c

#include "demo.h"
#include <stdlib.h>

struct ClassDemo
{
	int mI;
	int mJ;
};

Demo* Demo_Create(int i, int j)
{
	struct ClassDemo* ret = (struct ClassDemo*)malloc(sizeof(struct ClassDemo));
	
	if(ret)
	{
		ret->mI = i;
		ret->mJ= j;
	}
	
	return ret;
}

int Demo_GetI(Demo* d)
{
	int ret = -1;
	
	if(d)
	{
		struct ClassDemo* obj = (struct ClassDemo*)d;
		
		ret = obj->mI;
	}
	
	return ret;
}

int Demo_GetJ(Demo* d)
{
	int ret = -1;
	
	if(d)
	{
		struct ClassDemo* obj = (struct ClassDemo*)d;
		
		ret = obj->mJ;
	}
	
	return ret;
}

int Demo_Add(Demo* d, int value)
{
	int ret = -1;
	
	if(d)
	{
		struct ClassDemo* obj = (struct ClassDemo*)d;
		
		ret = obj->mI + obj->mJ + value;
	}
	
	return ret;
}

void Demo_Free(Demo* d)
{
	free(d);
}

main.c

#include "demo.h"
#include <stdio.h>

int main(void)
{
	Demo* d = Demo_Create(1, 2);
	
	if(d)
	{
		printf("i = %d\n", Demo_GetI(d));
		printf("j = %d\n", Demo_GetJ(d));
		printf("i + j + %d = %d\n", 3, Demo_Add(d, 3));
		
		Demo_Free(d);
	}
 	
	return 0;
}

我们用 C 语言模拟了 C++ 中 class 的部分特性，上面的代码体现了封装的特性，用户只知道成员函数的声明，不知道这个类里的有什么成员变量和成员函数的内部实现

在使用成员函数的时候，需要我们手动将对象的地址传递进去，这样函数能够知道使用的是哪个对象。在 C++ 中，一个类对象调用成员函数的时候，编译器会将这个对象的地址传递到成员函数中去

程序运行结果如下图所示：

继承对象模型

在 C++ 编译器的内部类可以理解为结构体

子类是由父类成员叠加子类新成员得到的

C++ 多态的实现原理

当类中声明虚函数时，编译器会在类中生成一个虚函数表

虚函数表是一个存储成员函数地址的数据结构

虚函数表是由编译器自动生成与维护的

virtual 成员函数会被编译器放入虚函数表中

存在虚函数时，每个对象都有一个指向虚函数表的指针

 

继承对象模型初探

#include <iostream>
#include <string>

using namespace std;

class Demo
{
protected:
    int mi;
    int mj;
public:
    virtual void print()
    {
        cout << "mi = " << mi << ", "
             << "mj = " << mj << endl;
    }
};

class Derived : public Demo
{
    int mk;
public:
    Derived(int i, int j, int k)
    {
        mi = i;
        mj = j;
        mk = k;
    }
    
    void print()
    {
        cout << "mi = " << mi << ", "
             << "mj = " << mj << ", "
             << "mk = " << mk << endl;
    }
};

struct Test
{
    void* p;
    int mi;
    int mj;
    int mk;
};

int main()
{
    cout << "sizeof(Demo) = " << sizeof(Demo) << endl;         
    cout << "sizeof(Derived) = " << sizeof(Derived) << endl;  
    
    Derived d(1, 2, 3);
    Test* p = reinterpret_cast<Test*>(&d);
    
    cout << "Before changing ..." << endl;
    
    d.print();
    
    p->mi = 10;
    p->mj = 20;
    p->mk = 30;
    
    cout << "After changing ..." << endl;
    
    d.print();
    
    return 0;
}

Demo 类中存在一个虚函数，所以编译器会给这个类的内存开始处塞一个指向虚函数表的指针Derived 类继承自 Demo 类，新增一个成员 mk

第 52 行，我们将 Derived 类强转为 Test 类，后续再对它的成员变量赋值，是验证 Derived 类的内存布局和 Test 类的内存布局是否相同

程序运行结果如下图所示：

通过打印可以看出，Derived 类的内存布局和 Test 类的内存布局是一样的，当类中存在虚函数时，那么编译器会往这个类的内存开始处塞一个指向虚函数表的指针，子类是由父类成员叠加子类新成员得到的

多态本质分析

demo.h

#ifndef __DEMO_H
#define __DEMO_H

typedef void Demo; 
typedef void Derived;

Demo* Demo_Create(int i, int j);
int Demo_GetI(Demo* d);
int Demo_GetJ(Demo* d);
int Demo_Add(Demo* d, int value);
void Demo_Free(Demo* d);

Derived* Derived_Create(int i, int j, int k);
int Derived_GetK(Derived* d);
int Derived_Add(Derived* d, int value);

#endif

demo.c

#include "demo.h"
#include <stdlib.h>

typedef struct
{
	int (*pAirtualAdd)(Demo*, int);
} vtable;

struct ClassDemo
{
	vtable* vptlb;
	int mI;
	int mJ;
};

struct ClassDerived
{
	struct ClassDemo demo;
	int mK;
};

static int Demo_VirtualAdd(Demo* d, int value);
static int Derived_VirtualAdd(Demo* d, int value);

static vtable demo_table = 
{
	Demo_VirtualAdd
};

static vtable derived_table = 
{
	Derived_VirtualAdd
};

Demo* Demo_Create(int i, int j)
{
	struct ClassDemo* ret = (struct ClassDemo*)malloc(sizeof(struct ClassDemo));
	
	if(ret)
	{
		ret->vptlb = &demo_table;
		ret->mI = i;
		ret->mJ= j;
	}
	
	return ret;
}

int Demo_GetI(Demo* d)
{
	int ret = -1;
	
	if(d)
	{
		struct ClassDemo* obj = (struct ClassDemo*)d;
		
		ret = obj->mI;
	}
	
	return ret;
}

int Demo_GetJ(Demo* d)
{
	int ret = -1;
	
	if(d)
	{
		struct ClassDemo* obj = (struct ClassDemo*)d;
		
		ret = obj->mJ;
	}
	
	return ret;
}

static int Demo_VirtualAdd(Demo* d, int value)
{
	int ret = -1;
	
	if(d)
	{
		struct ClassDemo* obj = (struct ClassDemo*)d;
		
		ret = obj->mI + obj->mJ + value;
	}
	
	return ret;
}

int Demo_Add(Demo* d, int value)
{	
	struct ClassDemo* obj = (struct ClassDemo*)d;
	
	return obj->vptlb->pAirtualAdd(d, value);
}

void Demo_Free(Demo* d)
{
	free(d);
}

Derived* Derived_Create(int i, int j, int k)
{
	struct ClassDerived* ret = (struct ClassDerived*)malloc(sizeof(struct ClassDerived));
	
	if(ret)
	{
		ret->demo.vptlb = &derived_table;
		ret->demo.mI = i;
		ret->demo.mJ = j;
		ret->mK = k;
	}
	
	return ret;
}

int Derived_GetK(Derived* d)
{
	int ret = -1;
	
	if(d)
	{
		struct ClassDerived* obj = (struct ClassDerived*)d;
		
		ret = obj->mK;
	}
	
	return ret;
}

static int Derived_VirtualAdd(Demo* d, int value)
{
	int ret = -1;
	
	if(d)
	{
		struct ClassDerived* obj = (struct ClassDerived*)d;
		
		ret = obj->mK + value;
	}
	
	return ret;
}

int Derived_Add(Derived* d, int value)
{	
	struct ClassDerived* obj = (struct ClassDerived*)d;
	
	return obj->demo.vptlb->pAirtualAdd(d, value);
}

main.c

#include "demo.h"
#include <stdio.h>

int Add(Demo* d, int value)
{
	int ret = Demo_Add(d, value);
	
	return ret;
}

int main(void)
{
	Demo* demo = Demo_Create(1, 22);
	Derived* derived = Derived_Create(1, 22, 333);
	
	if(demo && derived)
	{
		printf("%d\n", Add(demo, 10));
		printf("%d\n", Add(derived, 10));
		
		Demo_Free(demo);
		Demo_Free(derived);
	}
 	
	return 0;
}

上面的代码使用 C 语言实现了 C++ 的继承和多态特性，Demo 类为父类，Derived 类为子类，Demo 类里的 Add 函数为虚函数，所以我们需要为 Demo 类生成一个虚函数表，虚函数表是一个数据结构，里面存放着虚函数的地址，并且我们需要为 Demo 类的内存开始处塞一个虚函数指针，这个虚函数指针指向虚函数表，我们在创建 Demo 类对象的时候，会将 Demo 类的虚函数指针指向 Demo 类的虚函数表；由于 Derived 类继承自 Demo 类，所以 Derived 类里的 Add 函数也为虚函数，我们需要手动为 Derived 类创建一个虚函数表，创建 Derived 类对象的时候，将 Derived 类的虚函数指针指向 Derived 类的虚函数表。这样 Add 函数就具有了多态的特性，调用 Add 函数时，会根据实际的对象类型来调用

程序运行结果如下图所示：

Add 函数具有了多态特性

小结

C++ 中的类对象在内存布局上与结构体相同

成员变量和成员函数在内存中分开存放

访问权限关键字在运行时失效

调用成员函数时对象成员作为参数隐式传递

继承的本质就是父子间成员变量的叠加

C++ 中的多态就是通过虚函数表实现的

虚函数表是由编译器自动生成与维护的

虚函数表的调用效率低于普通函数

qq_52484093
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深度探索C++对象模型 侯捷
Zy_05_11的博客
01-15 2760
目录 什么是C++对象模型 第一章 关于对象 1.1 C++对象模式 1.2 关键词所带来的差异 1.3 对象的差异 多态 指针的类型 第二章 构造函数语意学 2.1 Default Constructor的构造操作 2.2 拷贝构造器的构造操作 2.3 程序转化语意学 2.4 成员们的初始化队伍 第三章 Data语意学 3.1...
C++对象模型源码下载
02-14
C++对象模型是C++编程语言的核心组成部分，它定义了如何在内存中表示类和对象，以及它们之间的关系。理解C++对象模型对于深入学习C++、优化代码性能以及调试程序至关重要。在这个源码下载中，你可以探索这些概念的...
深度探索C++ 对象模型
weixin_42252757的博客
11-13 1893
深度探索C++ 对象模型 第二章第一节 类对象所占用的空间 成员函数不占用类对象的内存空间一个类对象至少占用1个字节的内存空间成员变量是占用对象的内存空间成员函数 每个类只诞生 一个（跟着类走），而不管你用这个类产生了多少个该类的对象； 第二章第二节 对象结构的发展和演化 非静态的成员变量(普通成员变量)跟着类对象走（存在对象内部），也就是每个类对象都有自己的成员变量；静态成员变量跟对象没有什么关系，所以肯定不会保存在对象内部，是保存在对象外面（表示所占用的内存空间和类对象无关）的。成员函数：不管静态
c++ 对象模型
勤天下而拥家
09-13 1024
title: object-mode-layout date: 2022/09/12 tags: c++对象模型 categories: c++对象模型
深度探索C++对象模型
zzxiaozhao的博客
10-13 2624
深度探索C++对象模型参考链接:第1章 关于对象C++的额外成本三种对象模型简单对象模型表格驱动对象模型C++对象模型class和struct关键字的差异三种编程典范一个类的对象的内存大小一些结论[^3] 参考链接: 深度探索C++对象模型 笔记汇总 第1章 关于对象 C++的额外成本 C++较之C的最大区别，无疑在于面向对象。类相较于C的struct不仅只包含了数据，同时还包括了对于数...
【C++深度剖析教程28】C++对象模型分析
厚积薄发
04-07 1395
加qq1126137994，一起学习更多技术！ 今天记录学习的内容是：C++对象模型分析！！！ 本质分析： class是一种特殊的struct 在内存中class依旧可以看做是变量的集合 class与struct遵循相通的对齐准则 class中的成员函数与成员变量是分开存放的 *每个对象有独立的成员变量 *所有对象共享类中的成员函数 下图中的结果是什么？ 上面的结果需要分情...
c++对象模型分析（一）
cc猫
08-05 747
深夜睡不着觉，很痛苦。 关于对象 第一部分： 1.c++加上封装之后的成本： a.成员数据：c++ class中的成员数据等同于c中struct中的数据； b.非内联的成员函数：只会出现一个函数实体，由class中保存，由class实例化后的对象指向class中的函数地址； c.内联的成员函数：拥有一个或零个函数定义的内联函数会在每个使用者身上产生一个函数实体； 产生额外的负担）d.
C++:虚继承中对象模型分析
qq_45853229的博客
05-12 968
前言 我们知道 在多继承中，特别是 菱形继承中，会有两个问题： 内存的浪费。 二义性。 所以 引进了虚继承来 解决问题，虚继承和虚函数的原理很类似。 虚继承有 vbptr(虚基类指针） 指向 vbtable(虚基类表）。 那底层到底如何实现，我们 从 类的对象模型来分析。 对象模型分析 工具： vs 开发工具 命令： cl /d1reportSingleClassLayout[className] XXX.cpp 测试类 我们来看 类Bb 和 Cc 是怎样的布局： Cc 同理，我们就不演示了。
C++类对象的内存模型
Sundrops的专栏
05-06 6637
虚函数表 #include using namespace std; class Father { public: Father(){}; void ShowName(){ cout"Father"<<endl; } }; class Son : public Father { public: Son(){}; void ShowNa
图解 C++ 对象模型，看这一篇就够了！
luoyayun361的专栏
02-02 1383
《深度探索C++对象模型》这本书对对象模型的描述如下：语言中直接支持面向对象程序设计的部分，包括了构造函数、析构函数、多态、虚函数等等。对象模型的底层实现机制并未标准化，不同编译器有一定的自由来设计对象模型的实现细节。在我看来，对象模型研究的是对象在存储上的空间和时间上的更优，并对C++面向对象技术加以支持，如以虚指针、虚表机制支持多态特性。C++中虚函数的作用主要是为了实现多态机制。多态，简单来说，是指在继承层次中，父类的指针可以具有多种形态—当它指向某个子类对象时，通过它能够调用到子类的函数，而非父类的
深度探索C++对象模型之美
谢谢大家的关注
03-20 2937
从概念来上来讲，每一个没有定义构造函数的类都会由编译器来合成一个默认构造函数，以使得可以定义一个该类的对象，但是默认构造函数是否真的会被合成，将视是否有需要而定。C++ standard 将合成的默认构造函数分为 trivial(不重要) 和 notrivial(重要) 两种，前文所述的四种情况对应于notrivial默认构造函数，其它情况都属于trivial。对于一个trivial默认构造函数，编译器的态度是，既然它全无用处，干脆就不合成它。
C++对象内存模型.pdf
04-18
本文将通过实验和分析来探索 C++ 对象内存模型，并讨论对象内存结构、简单类型相关数据、包含虚函数类的对象内存结构、继承下的多态性等问题。 1. 实验基础 在 C++ 中，我们可以使用 sizeof 运算符来获取对象的...
C++对象模型探究(基础版)
03-12
总结来说，C++对象模型涉及到内存的五个主要区域：代码区、常量区、全局静态区、堆区和栈区。通过对String类的深入分析，我们可以了解到对象、函数、变量在内存中的位置，以及它们如何相互作用。理解这些基础知识...
C++ 多态
最新发布
wxk2227814847的博客
07-10 502
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【明文导入密钥(C/C++)】
m0_70748845的博客
07-07 401
以明文导入ECC密钥为例。具体的场景介绍及支持的算法规格。
C++初探究（2）
Frenemy__的博客
07-09 1278
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 993
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
C语言 do while 循环语句练习 中
2401_84378523的博客
07-05 607
注：使用Sleep首字母必须大写，引用头函数#include <windows.h>，Sleep是延时函数，用来做延时效果。使用system需应用头函数。
深度探索c++对象模型 pdf 2012
07-07
作者通过分析对象布局、虚函数表、虚函数调用、多继承中的数据布局和函数调用等等，解释了C++对象模型的实现机制。 在读者了解C++对象模型的基础上，该书还介绍了如何有效地利用对象模型来提高程序的性能。作者讨论...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值