C++动态内存管理（new/delete的使用）

c和c++的内存分布

粗略的可以将程序运行的内存分为以上几大部分：

1.内核空间：操作系统分配给内核的空间，为了保证内核安全，用户是不能访问这部分空间的。

2.栈区（stack）。由编译器自动分配释放，存放函数的参数值、局部变量的值等。函数在执行的时候，是在栈上开辟空间。

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

4.堆区（heap）。用于动态内存分配。一般由程序员分配和释放，若程序员不释放，程序结束时有的编译器自动回收。

4.数据段：存放全局数据，静态数据，字符串常量。

5.代码段：存放执行所需要的代码。

C++语言的动态内存管理方式
C语言中主要用到malloc() ; calloc ; realloc();动态在堆区申请空间，须要手动free()释放。
malloc/calloc/realloc函数的区别及用法

C++中主要是通过new和delete操作符进行动态内存管理:

1.new/delete操作内置类型

void Test()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];    
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

注意 new 类型(num）;与new 类型[num] 的区别

2.new/delete操作

2.1. new/delete自定义类型

#include<iostream>
using namespace std;
class Test
{
public:
	Test()
		: _data(0)
	{
		cout << "Test():" << this << endl;
	}
	~Test()
	{
		cout << "~Test():" << this << endl;
	}
private:
	int _data;
};
void Test1()
{
	// 申请单个Test类型的空间
	Test* p1 = (Test*)malloc(sizeof(Test));
	free(p1);
	// 申请10个Test类型的空间
	Test* p2 = (Test*)malloc(sizeof(Test) * 10);
	free(p2);
}

void Test2()
{
	// 申请单个Test类型的对象
	Test* p1 = new Test;
	delete p1;
	// 申请10个Test类型的对象
	Test* p2 = new Test[10];
	delete[] p2;
}
int main()
{
	cout << "test1()" << endl;
	Test1();
	cout << "test2()" << endl;
	Test2();
}

可以看到：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会；
new 会做两个工作： 1.开辟空间；2.调动构造函数。
delete也会两个工作： 1.调动析构函数；2.free()掉空间
Test* p2 = new Test[10] 这里申请10个Test类型的对象，会调动十次Test 的构造函数
delete[] p2; 这里释放10个Test类型的对象，会调动十次析构函数。

关于new和delete的底层实现是通过malloc和free()实现的：想深入了解的可以看看C++new和delete实现原理参考文章

2.2.operator new与operator delete函数

new作为一个操作符，对于内置类型，系统已经将new/delete的申请空间/释放空间的方式实现，可以直接使用。而对于自定义类型，大多时候我们需要自己来实现new/delete的申请空间/释放空间的方式,这就要借助操作符opreator对new进行重载。不同的类型有不同的实现方式。

下面的例子比较简单，但可以帮助理解上面所说的是什么意思：

#include<iostream>
using namespace std;
class Test
{
public:
	Test(int data = 0) : m_data(data)
	{
		cout << "Create Test Obj." << endl;
	}
	~Test()
	{
		cout << "Free Test Obj." << endl;
	}
public:
	void* operator new(size_t sz)     //注意： 这里参数规定为size_t
	{
		void* ptr = malloc(sz);
		return ptr;
	}
	void operator delete(void* ptr)  
	{
		free(ptr);
	}
	void* operator new[](size_t sz)
	{
		void* ptr = malloc(sz);
		return ptr;
	}
	void operator delete[](void* ptr)
	{
		free(ptr);
	}
private:
	int m_data;
};
void main()
{
	int* pt = new int;
	Test* pt1 = new Test;  //先调动自己实现的operator new （）开辟空间，再构造
	delete pt1;            //先调动自己实现的perator delete(),再析构。
}

2.3 new和delete的实现原理

1 内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
new的原理
调用operator new函数申请空间
在申请的空间上执行构造函数，完成对象的构造
delete的原理
在空间上执行析构函数，完成对象中资源的清理工作
调用operator delete函数释放对象的空间
new T[N]的原理
调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申
请
在申请的空间上执行N次构造函数
delete[]的原理
在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

3.定位new表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化.

可以通过下面这个简单例子理解一些定位new的用途：

void* operator new(size_t sz, void* ptr, int pos) 
{return &((int*)ptr)[pos];}

void main()
{
	int ptr[10] = { 0 };
	new(ptr, 5) int(1122);  //将Ptr[5] 赋值为1122
}

4.常见问题

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

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

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

2.什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。