C/C++：内存管理

1.C/C++的内存分配

内核空间：放置操作系统相关的代码和数据。（用户不能直接进行操作 ------ 可以通过调用系统提供的 api 函数）
内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。
数据段--存储全局数据和静态数据。
代码段--可执行的代码/只读常量。
堆区：由程序员手动分配和释放内存。可以使用new运算符在堆区分配内存，使用delete运算符释放内存。堆是可以向上增长的（动态内存分配）
栈区：栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。

2.C语言中的动态内存管理方式：

c语言中我们常用的动态内存管理方式是：malloc \ calloc \ realloc \ free

这几种函数我在之前的博客中做了详细的介绍，在此就不多赘述了。

3.C++内存管理方式

C语言内存管理方式在C++中可以连续使用，但有些地方就无能为力，而且试用起来就比较麻烦，所以C++提出了自己的内存管理方式，通过new和delete操作符进行动态内存管理。

new/delete 操作内置类型

c 复制代码

#include<iostream>
using namespace std;
void test()
{
	int* ptr1 = new int;
	int* ptr2 = new int(10);
	int* ptr3 = new int[3];
	delete ptr1;
	delete ptr2;
	delete[] ptr3;
}
int main()
{
	test();
	return 0;
}

注意：

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

new 和 delete 操作符自定义类型

c 复制代码

#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A()" << this << endl;
	}
	~A()
	{
		cout << "~A()" << this << endl;
	}
	void print()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p1 = new A(1);
	p1->print();
	delete p1;
	A* p2 = new A[10];
	delete[] p2;
	return 0;
}

注意：

在申请自定义类型的空间时，new 会调用构造函数，delete 会调用析构函数。

4.operator new 和 operator delete 函数

new 和 delete 是用户进行动态内存申请和释放的操作符，operator new 和 operator delete是系统提供的全局函数，new 在底层调用operator new 全局函数来申请空间，delete在底层调用operator delete全局函数来释放空间。

但是operator new 实际上也是通过malloc 来申请空间的，operator delete 最终是通过free 来释放空间的，而且operator delete 不会调用析构函数。

c 复制代码

#include <iostream>
using namespace std;

class A {
public:
A(int value) : _value(value) {
cout << "Constructor: A(" << _value << ")" << endl;
}
~A() {
cout << "Destructor: ~A()" << endl;
}

private:
int _value;
};

int main() {
// 使用 operator new 分配内存
void* ptr = operator new(sizeof(A));

// 在分配的内存上构造对象
A* obj = new(ptr) A(42);

// 显式调用析构函数
obj->~A();

// 使用 operator delete 释放内存
operator delete(ptr);

return 0;
}

与 new/delete 的区别

operator new/operator delete 只负责内存的分配和释放，不涉及对象的构造和析构。
new/delete 是操作符，除了调用 operator new/operator delete 外，还会自动调用构造函数和析构函数。
operator new/operator delete 可以被重载以实现自定义的内存管理，而 new/delete 的行为是固定的，不能被重载。

5.new 和 delete 的实现原理

对于内置类型

如果申请的是内置类型，new 和 malloc，delete 和 free 基本类似，不同的地方是：new / delete 申请和释放的是单个元素的空间，new [] 和 delete [] 申请的是连续的空间，new申请失败是会抛异常，而malloc 会返回NULL。

对于自定义类型

new 的原理：
1.调用operator new 函数申请空间
2.在申请的空间执行构造函数，完成对象的构造
delete 的原理：
1.在空间上执行析构函数，完成对象中的资源清理工作
2.调用operator delete 函数释放对象的空间
new T []的原理：
1.调用operator new[] 函数，实际上是调用operator new 函数完成N 个对象空间的申请，它的返回值是void*，使用时要强制类型转化。
2.在申请的空间上完成N 次拷贝构造函数
delete []的原理：
1.在释放的空间上先执行N次析构函数，完成N个对象中资源的清理
2.调用operator delete[] 释放空间，实际是在operator delete[] 中调用operator delete 来释放空间

6.定位new表达式（placement-new）

定位new表达式是在已分配的原始空间中调用构造函数初始化一个对象
使用格式 ：

new(place_address) type 或者new (place_address) type (initializer-list)

place_address 是一个指针，initializer-list是初始化列表
使用场景：

定位new表达式在实际中一般是配合内存池使用，因为内存池分配出的内存没有初始化，所以如果是自定义的类型的对象，需要使用new的定义表达式进行显示调用构造函数进行初始化。
内存池只负责分配「原始、空白、未初始化的内存块」，不负责构造对象、不负责初始化值。
内存池和 malloc 很像：只分配内存，不碰内容！

c 复制代码

#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A()" << this << endl;
	}
	~A()
	{
		cout << "~A()" << this << endl;
	}
	void print()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A;
	p1->~A();
	free(p1);
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->print();
	p2->~A();
	operator delete(p2);
	return 0;
}

7. malloc / free 和 new / delete 的区别

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

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