C/C++内存管理【C++】

news2024/11/19 20:42:46

一、 C/C++内存分布

在这里插入图片描述
C/C++程序的内存布局会因编译器和操作系统而有所不同，但基本结构相似，简单地介绍了几个关键区域。

那为什么我们要进行分区域呢？
因为程序中需要各种不同的数据(生命周期) 和为了方便数据管理

首先来看一段代码

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
const char* pChar3 = "abcd";
int* ptr1 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
free(ptr1);
free(ptr3);
}

根据上方代码

选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
1.globalVar在哪里？____ 2.staticGlobalVar在哪里？____
3.staticVar在哪里？____ 4.localVar在哪里？____
5.num1 在哪里？____
6.char2在哪里？____ 7.*char2在哪里？___
8.pChar3在哪里？____ 9.*pChar3在哪里？____
10.ptr1在哪里？____ 11.*ptr1在哪里？____
选择答案：
C C C A A A A A D A B
填空题：
sizeof(num1) = ____;
sizeof(char2) = ____; strlen(char2) = ____;
sizeof(pChar3) = ____; strlen(pChar3) = ____;
sizeof(ptr1) = ____;
答案: 40 5 4 4/8 4 4/8

C语言中动态内存管理方式：malloc/calloc/realloc/free等
C语言动态内存详细介绍 请猛戳此处

1. C++内存管理方式

C++提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理

当然C语言内存管理方式在C++中可以继续使用

(1) new和delete操作内置类型

只分配空间

// 例 1 在堆上分配一个空间
	int* p1 = new int; //表示在堆上动态分配一个整数的大小的内存，返回的地址赋值给指针变量 p1
	//...
	delete p1;	//使用 new 分配的内存必须在不再需要时手动释放，以避免内存泄漏

// 例 2 在堆上分配多个空间
	int* p2 = new int[10]; //表示在堆上要多个int对象,p2 是一个指向整数的指针，它被初始化为新分配的数组的首地址
	//...
	delete[] p2;		   //注意释放的形式

分配空间同时初始化

// 例 1 分配一个空间并初始化
	//在堆上动态分配了一个整型变量并初始化为10，指向该整型变量的指针赋值给指针变量p3
	int* p3 = new int(10);
	//...
	delete p3;

// 例 2 分配一个空间并初始化
	int* p4 = new int[10] {1,2,3,4,5};	//在堆上动态分配了多个空间并部分初始化，然后将指向该数组首元素的指针赋值给指针变量p4
	//...
	delete[] p4;

小总结：
申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]

(2) new和delete操作自定义类型

// 例如 链表
struct ListNode
{
	~ListNode()
	{
		_next = nullptr;
		_prev = nullptr;
		_val = 0;
		cout << "~ListNode()" << endl;
	}
	ListNode* _next;
	ListNode* _prev;
	int _val;

	//构造
	ListNode(int val)
		:_next(nullptr)
		,_prev(nullptr)
		,_val(val)
	{}
};

int main() 
{
	//new操作符 在为自定义类型申请空间时，会去调用构造函数
	//如果new失败了后抛异常，不需要手动检查
	ListNode* node1 = new ListNode(1);
	ListNode* node2 = new ListNode(2);
	ListNode* node3 = new ListNode(3);

	//delete操作符 会去调用析构函数
	delete node1;
	delete node2;
	delete node3;

	return 0;
}

小总结：
在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会

二、 operator new与operator delete函数

new 和 delete 是进行动态内存申请和释放的操作符

operator new 和 operator delete 是系统提供的全局函数

new 在底层会去调用operator new 全局函数来申请空间，delete 在底层通过operator delete全局函数来释放空间

operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。

	// 对于内置类型,本质和malloc并没有什么区别
	int* p1 = (int*)operator new(10*4);	
	//注意 operator new 不是运算符重载
	//int *p1 = (int*)new(10*4);	//error,运算符重载

	//对于自定义类型,
	A* ptr1 = new A;
	A* ptr2 = new A[10];	//动态分配了一个包含10个 A 类型对象的数组

自定义类型汇编
在这里插入图片描述
调用的底层顺序

operator new 是对 malloc 的封装，为了解决失败后进行抛异常和实现new

new的原理：调用operator new函数申请空间，再申请的空间上执行构造函数，完成对象的构造

new A[n]的原理 : 调用operator new[]函数，再operator new[]中实际调用operator new函数完成n个对
象空间的申请,再申请的空间上执行n次构造函数

operator delete: 该函数最终是通过free来释放空间的

对于内置类型的delete本质上和free区别不大

对于自定义类型

	//对于自定义类型,
	A* ptr1 = new A;	//operator new + 1次构造
	A* ptr2 = new A[10];	//operator new[] + 10次构造

// 注意 这里是先进行 析构 再去调用 operator delete
	delete ptr1;	// 先 1次析构 再去调用operator delete
	delete[] ptr2;	// 先 10次析构 再去调用 operator delete[]