50-51 - C++ 对象模型分析

已于 2023-11-24 11:18:41 修改
阅读量587 收藏
点赞数
分类专栏： C++ 深度解析教程 文章标签： c++ 开发语言
于 2022-11-26 15:50:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36098975/article/details/128037674
版权
本文深入探讨了C++中的类与struct的内存布局，指出class本质上是特殊的struct，成员函数与成员变量分开存放。通过编程实验展示了对象内存的分布，包括继承和多态的对象模型。同时，揭示了C++中多态的实现原理，即通过虚函数表实现，每个对象含有指向虚函数表的指针。最后，强调了C++中访问权限在编译时有效，运行时可以通过指针间接修改成员变量。
摘要由CSDN通过智能技术生成

---- 整理自狄泰软件唐佐林老师课程

文章目录

1. 回归本质

1.1 class 是一种特殊的 struct

  • 在内存中 class 依旧可以看作 变量的集合
  • class 与 struct 遵循相同的 内存对齐 规则
  • class 中的成员函数与成员变量是 分开存放 的
    • 每个对象有独立的成员变量
    • 所有对象共享类中的成员函数

在这里插入图片描述

1.2 值得思考的问题

在这里插入图片描述

1.3 编程实验：对象内存布局初探

#include <iostream>
#include <string>

using namespace std;

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

struct B
{
    int i; // 4
    int j; // 4
    char c; // 1 --> 8
	double d; // 8
};

int main()
{
    A a;
    cout << "sizeof(A) = " << sizeof(A) << endl;
    cout << "sizeof(a) = " << sizeof(a) << endl;
    cout << "sizeof(B) = " << sizeof(B) << endl;
    a.print();
    
    B* p = reinterpret_cast<B*>(&a); // 强制类型转换，重解释 A 这一段内存
									 // struct 解释 class
    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;
}

在这里插入图片描述

2. C++ 对象模型分析

2.1 对象本质分析

  • 成员变量：
    • 运行时的对象退化为 结构体 的形式
    • 所有成员变量在内存中 依次排布
    • 成员变量间 可能存在内存空隙
    • 可以通过对象的内存地址直接访问成员变量
    • 访问权限在编译时有效，一旦编译通过，访问权限 在运行时失效，运行时就可以通过指针修改成员变量的值
  • 成员函数：
    • 类中的成员函数位于代码段中
    • 调用成员函数时 对象地址 作为参数 隐式传递（this 指针）
    • 成员函数通过 对象地址 访问成员变量
    • C++ 语法规则 隐藏了 对象地址的传递过程

2.1.1 编程实验：对象本质分析

#include <iostream>
#include <string>

using namespace std;

class Demo
{
    int mi;
    int mj;
public:
    Demo(int i, int j) {
        mi = i;
        mj = j;
    }
    int getI() {
		cout << "this: " << this << endl;
        return mi;
    }
    int getJ() {
		cout << "this: " << this << endl;
        return mj;
    }
    int add(int value) {
		cout << "this: " << this << endl;
        return mi + mj + value;
    }
};

int main()
{
    Demo d(1, 2);
    
    cout << "sizeof(d) = " << sizeof(d) << endl;
    cout << "&d = " << &d << endl;
    cout << "d.getI() = " << d.getI() << endl; // d 对象的地址被传入到成员函数内部
    cout << "d.getJ() = " << d.getJ() << endl;
    cout << "d.add(3) = " << d.add(3) << endl;
    
    return 0;
}

在这里插入图片描述

2.1.2 用 C 语言模拟

#ifndef __DEMO_H_
#define __DEMO_H_

typedef void Demo;

Demo* Demo_create(int i, int j);
int Demo_GetI(Demo* pThis);
int Demo_GetJ(Demo* pThis);
int Demo_Add(Demo* pThis, int value);
void Demo_Free(Demo* pThis);

#endif

#include <malloc.h>
#include "demo.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 != NULL) {
		ret->mi = i;
		ret->mj = j;
	}
	return ret;
}

int Demo_GetI(Demo* pThis)
{
	struct ClassDemo* obj = (struct ClassDemo*)pThis;
	return obj->mi;
}

int Demo_GetJ(Demo* pThis)
{
	struct ClassDemo* obj = (struct ClassDemo*)pThis;
	return obj->mj;
}

int Demo_Add(Demo* pThis, int value)
{
	struct ClassDemo* obj = (struct ClassDemo*)pThis;
	return obj->mi + obj->mj + value;
}

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

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

int main()
{
	Demo* d = Demo_create(1, 2); // 模拟 Demo* d = new Demo(1,2);
	printf("d.mi = %d\n", Demo_GetI(d)); // 模拟 d->GetI();
	printf("d.mj = %d\n", Demo_GetJ(d)); // 模拟 d->GetJ();
	printf("Add(3) = %d\n", Demo_Add(d, 3)); // 模拟 d->Add(3);
	
	// d->mi = 100; // 编译报错，模拟 C++ 外界不能访问私有成员
	
	Demo_Free(d); // 模拟 C++ 中的析构
	
	return 0;
}

在这里插入图片描述

2.2 继承对象模型

  • 在 C++ 编译器的内部，类可以理解为结构体
  • 子类是由 父类成员叠加子类新成员 得到的（父类在前，子类在后）

在这里插入图片描述

  • 编程实验：继承对象模型初探
#include <iostream>
#include <string>

using namespace std;

class Demo
{
public:
    int mi;
    int mj;
};

class Derived : public Demo
{
public:
	int mk;
};


int main()
{
	Derived d;
	
	cout << "&d.mi = " << &d.mi << endl;
	cout << "&d.mj = " << &d.mj << endl;
	cout << "&d.mk = " << &d.mk << endl;
	
    cout << "sizeof(Demo)    = " << sizeof(Demo) << endl;
    cout << "sizeof(Derived) = " << sizeof(Derived) << endl;
    
    return 0;
}

在这里插入图片描述

#include <iostream>
#include <string>

using namespace std;

class Demo
{
protected:
    int mi;
    int mj;
};

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 {
	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);
	d.print();
	
	cout << "Before changing ..." << endl;

	p->mi = 10;
	p->mj = 20;
	p->mk = 30;
	
	cout << "After changing ..." << endl;
	
	d.print();
    
    return 0;
}

在这里插入图片描述

2.3 多态对象模型

  • 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;
	}
};

int main()
{
	cout << "sizeof(void*)   = " << sizeof(void*) << endl;
    cout << "sizeof(Demo)    = " << sizeof(Demo) << endl;
    cout << "sizeof(Derived) = " << sizeof(Derived) << endl;
    
    return 0;
}

在这里插入图片描述

  • 指向虚函数表的指针放在 最开始的 4 个字节处（32 位环境），可通过如下实验验证：
#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(void*)   = " << sizeof(void*) << endl;
    cout << "sizeof(Demo)    = " << sizeof(Demo) << endl;
    cout << "sizeof(Derived) = " << sizeof(Derived) << endl;
	
	Derived d(1, 2, 3);
	Test* p = reinterpret_cast<Test*>(&d);
	d.print();
	
	cout << "Before changing ..." << endl;

	p->mi = 10;
	p->mj = 20;
	p->mk = 30;
	
	cout << "After changing ..." << endl;
	
	d.print();
    
    return 0;
}

在这里插入图片描述

  • 用 C 语言实现多态：
#ifndef __DEMO_H_
#define __DEMO_H_

typedef void Demo;
typedef void Derived;

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

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

#endif

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

static int Demo_Virtual_add(Demo* pThis, int value);
static int Derived_Virtual_add(Demo* pThis, int value);

struct VTable { // 2. 定义虚函数表数据结构
	int (*pAdd)(void*, int); // 3. 虚函数表里存储的是什么？
};

struct ClassDemo {
	struct VTable* vptr; // 1. 定义虚函数表的指针，虚函数表指针的类型是什么样？
	int mi;
	int mj;
};

struct ClassDerived {
	struct ClassDemo d;
	int mk;
};

static struct VTable g_Demo_vtbl = {
	Demo_Virtual_add
};

static struct VTable g_Derived_vtbl = {
	Derived_Virtual_add
};

Demo* Demo_Create(int i, int j)
{
	struct ClassDemo* ret = (struct ClassDemo*)malloc(sizeof(struct ClassDemo));
	if (ret != NULL) {
		ret->vptr = &g_Demo_vtbl; // 4. 关联对象和指向的具体的虚函数表
		ret->mi = i;
		ret->mj = j;
	}
	return ret;
}

int Demo_GetI(Demo* pThis)
{
	struct ClassDemo* obj = (struct ClassDemo*)pThis;
	return obj->mi;
}

int Demo_GetJ(Demo* pThis)
{
	struct ClassDemo* obj = (struct ClassDemo*)pThis;
	return obj->mj;
}

// 6. 定义虚函数表中指针所指向的具体函数
static int Demo_Virtual_add(Demo* pThis, int value)
{
	struct ClassDemo* obj = (struct ClassDemo*)pThis;
	return obj->mi + obj->mj + value;
}

// 5. 分析具体的虚函数
int Demo_Add(Demo* pThis, int value)
{
	struct ClassDemo* obj = (struct ClassDemo*)pThis;
	return obj->vptr->pAdd(pThis, value); // 通过对象，找到指向虚函数表的指针，
										  // 然后在虚函数表中找到具体要调用的函数地址
}

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

Derived* Derived_Create(int i, int j, int k)
{
	struct ClassDerived* ret = (struct ClassDerived*)malloc(sizeof(struct ClassDerived));
	if (ret != NULL) {
		ret->d.vptr = &g_Derived_vtbl;
		ret->d.mi = i;
		ret->d.mj = j;
		ret->mk = k;
	}
	return ret;
}

int Derived_GetK(Derived* pThis)
{
	struct ClassDerived* obj = (struct ClassDerived*)pThis;
	return obj->mk;
}

static int Derived_Virtual_add(Demo* pThis, int value)
{
	struct ClassDerived* obj = (struct ClassDerived*)pThis;
	return obj->mk + value;
}

int Derived_Add(Derived* pThis, int value)
{
	struct ClassDerived* obj = (struct ClassDerived*)pThis;
	return obj->d.vptr->pAdd(pThis, value);
}

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

void run(Demo* p, int v)
{
    int r = Demo_Add(p, v);
    printf("r = %d\n", r);
}

int main()
{
    Demo* pb = Demo_Create(1, 2);
    Derived* pd = Derived_Create(10, 20, 30);
    
    printf("pb->add(3) = %d\n", Demo_Add(pb, 3));
    printf("pd->add(30) = %d\n", Derived_Add(pd, 30));
    
    run(pb, 3);
    run(pd, 30);
    
    Demo_Free(pb);
    Demo_Free(pd);
	
	return 0;
}

在这里插入图片描述

3. 小结

  • C++ 中的类对象在内存布局上与结构体相同
  • 成员变量和成员函数在内存中分开存放
  • 访问权限关键字在运行时失效
  • 调用成员函数时对象地址作为参数隐式传递
  • 继承的 本质 是父子间成员变量的 叠加
  • C++ 中的多态是通过虚函数表实现的
  • 虚函数表是由编译器自动生成与维护的
  • 虚函数的调用效率低于普通函数
uuxiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++对象模型探索-王健伟-专题视频课程
KuangXiang的专栏
10-12 4377
c++对象模型知识久负盛名，在c++界具有很高的美誉度，这方面知识的学习，更是被诸多颇具开发实力的行业前辈倾力推荐！ 本门课程内容将涉及到很多不被常人所知的 c++对象内部工作原理、底层的一些具体实现机制方面的知识，本门课程属于“提高个人c++开发修养，练习c++编程内功的一门课程”，课程定位为"c++大师进阶级"课程。...
C++对象模型分析
嗤嗤的博客
11-10 87
C++对象模型分析 class是一种特殊的struct 在内存中class依旧可以看作变量的集合 class与struct遵循相同的内存对齐规则 class中的成员函数与成员变量是分开存放的 每个对象有独立的成员变量 所有对象共享类中的成员函数 #include <iostream> using namespace std; class A { int i; int j; char c; double d; }; struct B { .
gcc下c++对象模型，对象内存分布
zxc151643的博客
11-29 1092
GCC对象内存布局（win10） gdb调试的一些用法： C:\Users\huangx\Desktop\Test> g++ -std=c++11 -g -o test test.cpp //-g 加入调试信息 C:\Users\huangx\Desktop\Test> gdb test //进入调试 (gdb) set p pretty on //美化print的输出 (gdb) b 47 //break line设置断点 (gdb) r //run 运行程序 (gdb) p d //打印对象
OpenGL学习-球体和phong光照模型
快乐的小小程序猿
09-03 1885
OpenGL学习-球体和phong光照模型 开发环境搭建参考：https://lexiaoyuan.blog.csdn.net/article/details/120059213 通用配置步骤 Visual Studio，创建一个新的空项目 复制glad.c文件到你的工程中 选中项目，右键选择属性–> C/C++目录–> 常规–> 包含目录：加上头文件存放的目录 选中项目，右键选择属性–> C/C++目录–> 常规–> 库目录：加上lib文件存放的目录 选中项目，
C++对象模型
杨龙飞的博客
02-05 1274
1.C++对象模型概述 有两个概念可以解释C++对象模型 1.语言中直接支持面向对象程序设计的部分 包括了构造函数、析构函数、多态、虚函数等等. 2.对于各种支持的底层实现机制 对象模型研究的是对象在存储上的空间与时间上的优化,并对C++面向对象技术加以支持,如以虚指针、虚表机制支持多态机制. 2.理解虚函数表2.1多态与虚表C++中虚函数
znFAT-51.rar_单片机开发_C/C++_
08-11
C/C++是常见的单片机编程语言，C语言提供了底层硬件访问的能力，而C++则提供了面向对象的编程模型，可以更好地组织代码结构。在51单片机上使用这两种语言时，需要注意内存管理，避免动态分配内存，因为51单片机的RAM...
C++基础---面向对象程序设计
Catherine的笔记
09-13 2790
1. 面向对象的程序设计 1.1 面向对象程序设计的定义 面向对象编程：Object Oriented Programming（简称OOP），面向对象程序设计。 面向对象程序设计： (1)面向对象程序设计是一种计算机编程架构。面向对象程序设计的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。 (2)面向对象程序设计是一种程序设计范型，同时也是一种程序开发的方法。对象指的是类的实例。它将
Be-played-by-keyboard.zip_单片机开发_C++_
08-11
2. **C++在嵌入式系统中的应用**：虽然51单片机通常与C语言关联，但本项目使用了C++，这意味着可能使用了C++的面向对象特性来组织代码，如类、对象、继承和多态等。 3. **音乐理论与数字音频**：要实现电子琴功能，...
CCF CSP-J 2022 第一轮 C++语言试题
提灯汇
09-18 903
2022 CCF 非专业级别软件能力认证第一轮 （CSP-J1）入门级 C++语言试题
C++与QML的数据交互
qq_50679120的博客
09-11 313
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 533
C语言 | Leetcode C语言题解之第389题找不同
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 154
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 299
QWidget(c++)嵌入window环境的exe
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 948
💫往期文章👇：
C语言作用域
天道酬勤
09-07 974
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
C和指针：标准函数库
暮色年华的博客
09-11 458
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
完全背包（C++）
lim6ere的博客
09-11 595
DP42 【模板】完全背包以上就是今天要讲的内容，本文仅仅详细介绍了。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
C语言从头学59——学习头文件math.h（二）
最新发布
m0_72128260的博客
09-11 142
继续学习头文件的数学函数。
c++ 类的继承详解
HJQD777的博客
09-07 489
继承允许类之间建立层次关系，促进代码重用和扩展。继承有不同的访问控制方式（publicprotectedprivate），影响派生类对基类成员的访问权限。基类的构造函数和析构函数不会被继承，派生类需要自行定义。使用虚函数和多态可以实现灵活的接口设计和动态方法调用。理解继承机制对于设计高效、灵活和可维护的面向对象系统至关重要。
C++：系统开发、服务器与面向对象编程的基石
C++更侧重于构造对象模型，通过对象的交互来解决问题，而不是单纯地关注算法和数据结构。这种面向对象的思维方式使得C++在解决复杂问题时更具优势。 学习C++，可以通过狄泰学院的《C++深度解析教程》和天山老妖在其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

uuxiang

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

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

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

打赏作者

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

抵扣说明：

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

余额充值