C++的内存管理_c++ 内存管理-CSDN博客

本文链接：https://blog.csdn.net/wutongguo/article/details/129517522

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.代码段(常量区)
globalVar在哪里？__ C __ staticGlobalVar在哪里？__ C __
staticVar在哪里？__ C __ localVar在哪里？__ A __
num1 在哪里？__ A __
char2在哪里？__ A __ *char2在哪里？__ A __
pChar3在哪里？__ A __ *pChar3在哪里？__ D __
ptr1在哪里？__ A __ *ptr1在哪里？__ B __

globalVar属于全局变量，所以存放在静态区。
staticGlobalVar，属于静态的全局变量，静态成员存放在静态区。
staticVar是一个静态的局部变量，存放在静态区。
localVar，是一个局部变量，存放在栈区。
num1，是一个数组名，表示首元素的地址，所以也是一个局部变量存放到栈区中。
char2,是一个数组名，表示首元素的地址，所以也是一个局部变量存放到栈区中。
*char2,解引用，表示数组首元素的数据，我们char2是一个在栈上的数组，将我们的常量字符拷贝的数组上，所以我们*char存放到栈上。
pChar3,是一个常量指针，在这个函数中，所以属于栈区。
*pChar3，对于这个常数组解引用，表示这个常量字符串，既然是常量，就存放在常量区。
ptr1 是一个地址，存放在函数上，所以也是一个局部变量存放到栈区中。
*ptr1是我们动态开辟的空间，存放在堆上。

注意

栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。

内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信

堆用于程序运行时动态内存分配，堆是可以上增长的。

数据段–存储全局数据和静态数据。

代码段–可执行的代码/只读常量。

C++的动态内存管理

我们先回忆一下malloc calloc，realloc
malloc:开辟空间，但是不初始化。
calloc：开辟空间，但是初始化为0.
realloc:扩容，但是分为原地扩容，和异地扩容

C++依旧可以使用，但是又出现了新的关键字new和delete

一、`new`和`delete`

我们在C++阶段我们就尽量不要再用malloc和realloc，
我们使用new至于为什们看下面不同类型的对比就可以。

①开辟内置类型

先看样例

int main()
{
	//初始化单个对象
	//C语言初始化
	int* p1 = (int*)malloc(sizeof(int));
	//C++初始化
	int* pp1 = new int;
	//C销毁
	free(p1);
	//C++销毁
	delete pp1;

	//初始化多个对象
	//C语言初始化
	int* p2 = (int*)malloc(sizeof(int) * 10);
	//C++初始化
	int* pp2 = new int[10];
	//C销毁
	free(p2);
	//C++销毁
	delete[] pp2;
	return 0;
}

我们通过调试发现，好像对于C++来说好像跟C语言一样，在开辟空间的时候都不初始化。
所以在定义内置类型的时候，new和malloc基本相同.

我们malloc不能初始化，但是new在其实也可以初始化。
大家看代码举一反三

int main()
{
	//这个不会初始化
	int* p1 = new int;
	delete p1;
	//这个初始化,申请一个，初始化为10
	int* p2 = new int(10);
	delete p2;
	//创建10个数据的数组
	int* p3 = new int[10];
	delete[]p3;
	//10个数据的数组初始化,将前4个初始化为特定的，其他为0
	int* p4 = new int[10]{ 1,2,3,4 };
	delete[]p4;
	return 0;
}

`delete`和`free`不要混着用

malloc用free
new用delete
可能会出问题，也可能不会。结果是不确定的。

②开辟自定义类型

我们c语言怎么开辟自定义类型的空间。

我们想一想在学习链表的时候，我们好像在创建一个链表的时候，我们好像写了一个函数，先用malloc创建一个结点的空间，然后我们再初始化。

但是对于C++，来说，我们可以直接用new，我们就及创建了空间，又将内容初始化，所以我们以后创建空间就用new

//这是一个链表，我们一会就要创建这个链表。
struct ListNode
{
	ListNode(int val)
		:_val(val)
		, _next(nullptr)
	{

	}
private:
	int _val;
	ListNode* _next;
};

int main()
{
	//对于自定义类型，会用new会调用构造函数，然后在初始化列表中初始化。
	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);
	return 0;
}

二、`operator new`与`operator delete`函数

注意

operator new 和 operator delete是系统提供的 全局函数。并不是运算符重载。
new在底层调用 operator new 全局函数来申请空间.
delete在底层通过 operator delete 全局函数来释放空间。

operator new参数类型

void* operator new (size_t size) throw (bad_alloc);
我们发现其实跟malloc一样

operator new和malloc的区别

我们的 operator new失败了会抛异常
malloc失败了会返回空指针

int main()
{
	//失败了抛异常
	int* p1 = (int*)operator new(sizeof(int));

	//失败返回空指针
	int* p2 = (int*)malloc(sizeof(int));
	if (p2 == nullptr)
	{
		perror("malloc fail");
	}

}

① `new`的机制

new的两个作用

用operator new申请空间
调用构造函数

因为面向对象的语言，失败了都喜欢用抛异常而不是空指针。
所以在申请空间的时候用operator new将malloc封装，然后失败了就会抛异常。

① `delete`的机制

delete的两个作用

先调用析构函数
再用 operator delete释放空间

在释放空间的时候用operator new将free封装。

为什们 delete和 free不要混着用？

我们如果用 new开辟空间，用 free释放空间，我们就可能不调用析构函数。直接是释放空间。（因为释放空间的时候用 operator new将 free封装）。

结论

new/malloc系列，有底层实现机制有关联交叉。
可能有问题，可能没问题，必须匹配使用。

三、malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：

malloc和free是函数，new和delete是操作符
malloc申请的空间不会初始化，new可以初始化
malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可
malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
申请自定类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。

四、定位`new`

假设我们先用malloc开辟空间了，但是我们没有初始化。
这时我们去初始化，有没有什么办法呢？
就要用我们的定位new

定位 new的作用

表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

定位 new的使用格式

new (place_address) type 或者
new (place_address) type(initializer-list)
place_address必须是一个指针， initializer-list是类型的初始化列表

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
	}
private:
	int _a;
};
int main()
{
	A aa;
	A* p1 = (A*)malloc(sizeof(A));
	if (p1 == nullptr)
	{
		perror("malloc fail");
	}
	//定义new
	//p1找到要初始化的位置
	//A(1)构造函数。初始化内容
	new(p1)A(1);
	
	//释放空间
	p1->~A();
	free(p1);
}