目录
C/C++内存分布
我们所熟知的存放数据的区域主要有：栈 ，堆 ，静态区(数据段) ,常量区(代码段) ，当然不止这些区域，在这些区域分别存储局部数据 ，静态和全局数据 ，常量 ，动态申请的数据
C++动态内存管理方式
在学习过C语言之后，我们知道C语言是通过malloc/calloc/realloc/free等来进行我们的内存管理的，在使用过程中，我们能明显感觉到C语言实现动态内存管理有它一定的局限性。
对比以下代码：
cpp
void Test()
{
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
int* p3 = new int(1);
free(p1);
delete p2, p3;
}上述代码都是动态申请一个int类型的空间。对比一下C语言和C++动态申请内存空间，可以发现，C++动态申请内存空间更加的方便和高效；接下来介绍一下C++动态内存管理的方式：
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
1.new/delete操作内置类型：
cpp
void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[10];
delete ptr4;
delete ptr5;
delete[] ptr6;
}那么动态申请多个空间怎么进行初始化呢：其实就是加上{}，在{}里面写数据
cpp
int* ptr6 = new int[10]{0};但是，C++改用new和delete作为动态内存管理的方式肯定不是只为了比C语言方便和高效率的，它主要的作用在于对自定义类型的动态申请空间上 ：
2.new/delete操作自定义类型：
new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
cpp
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << " A(int a = 0)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
void Test()
{
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A;
free(p1);
delete(p2);
}
int main()
{
Test();
return 0;
}运行之后只有new和delete调用了构造和析构函数
接下来再看看动态申请多个空间：
同时这里需要注意，我们如果在申请多个对象的同时进行初始化，要注意是否有适配的构造函数：
cpp
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << " A(int a = 0)" << endl;
}
private:
int _a;
};
void Test()
{
A* p2 = new A[10]{ 1,2,3,4 };
delete[] p2;
}比如说这里，我们是默认构造函数，不给值初始化_a的话会用其缺省值，所以我们在new多个空间的时候不需要给所有对象都初始化。
而如果我们是用自己写的构造函数时
cpp
class A
{
public:
A(int a )//非默认构造函数
:_a(a)
{
cout << " A(int a = 0)" << endl;
}
private:
int _a;
};
void Test()
{
A* p2 = new A[10]{ 1,2,3,4 };
delete[] p2;
}
int main()
{
Test();
return 0;
}它就会报错，这跟之间的初始化列表的问题一样，需要我们手动的进行给值进行初始化，所以我们把对象都手动给值他就不会报错了。
cpp
A* p2 = new A[10]{ 1,2,3,4,5,6,7,8,9,10};补充：
上述的开辟的多个空间进行初始化涉及到隐式类型转化，也可以用匿名对象进行初始化。
cpp
A* p2 = new A[4]{ A(1),A(2),A(3),A(4) };这里什么要提到匿名对象进行初始化操作呢，是因为有时候构造函数需求的参数有多个，这个时候要想初始化就得用匿名对象。
cpp
class A
{
public:
A(int a ,int b)
:_a(a)
{
cout << " A(int a = 0)" << endl;
}
private:
int _a;
};
void Test()
{
A* p2 = new A[2]{ A(1,1),A(1,2)};
delete[] p2;
}这时候就只能用匿名对象。
注意：
new和delete一定要配套使用，如果部配套使用，可能会出现一些问题
new和delete的底层实现
new和delete底层实现分为两个部分：
new:先开空间，再调用构造函数
delete:先析构，再清理空间
为什么会是这样的底层逻辑呢。
首先来知道一下：new在底层调用operator new函数来开空间，delete在底层是调用operator delete来清理空间
我们来看看这两个函数：
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数
operator new
cpp
//**operator new**
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
// try to allocate size bytes
void *p;
while ((p = malloc(size)) == 0)//调用malloc
if (_callnewh(size) == 0)
{
// report no memory
// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}首先看operator new这个函数,在我注释的地方它调用了malloc函数，也就是说，其实operator new是通过调用malloc来开辟空间，不一样的是，在C语言中用malloc开辟空间失败之后，会返回空。而C++中operator new 开辟空间失败，它会抛出bad_alloc异常，这里涉及到一个抛异常的知识点，在后面我会补充到。
这里演示一下：
malloc:
operator new:
对比一下会发现，当malloc申请空间失败，尝试执行空；operator new申请空间失败，会抛异常。再来看operator new中抛出异常给的提示是bad_alloc，与我们调试过后给的错误信息一样。
既然抛异常，我们也可以捕获异常，在C++中捕获异常是这样的：
cpp
int main()
{
A* p = nullptr;
try {
do
{
p = new A[1024*1024];
cout << p << endl;
} while (p);
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
operator delete
cpp
//**operator delete**
void operator delete(void *pUserData)
{
_CrtMemBlockHeader * pHead;
RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData == NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */
__TRY
/* get a pointer to memory block header */
pHead = pHdr(pUserData);
/* verify block type */
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg( pUserData, pHead->nBlockUse );//**调用_free_dbg**
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}同样的，operator delete其实也是使用了free这个函数，在我们注释的地方它调用的是_free_dbg；这是因为free函数是使用的宏定义的
cpp
#define free(p) _free_dbg(p, _NORMAL_BLOCK)好了，既然已经了解到了new和delete的底层实现，那么我们来直观的看一看这个实现的原理：
对于内置类型：
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
对于自定义类型：
new的原理
- 调用operator new函数申请空间
- 在申请的空间上执行构造函数，完成对象的构造
delete的原理
- 在空间上执行析构函数，完成对象中资源的清理工作
- 调用operator delete函数释放对象的空间
这里析构和operator delete被封装进了上面这个scalar deleting destructor函数。
这其中还有开辟多个空间和清理多个空间：
new T[N]的原理
调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申 请
在申请的空间上执行N次构造函数
delete[]的原理
1.在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2.调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间
比如我们用new来创建数组，就要用到new[],清理这个数组空间则用delete[]。
补充：
new要先开空间再调用构造函数我们知道必须开空间之后才能创建对象，那delete为什么是先析构之后再清理空间呢
这里先说结论，先清理掉对象中的资源，防止因为先清理对象空间后无妨找到对象导致无法对对象的资源进行清理
举例说明：
注：任何类型的指针都是内置类型。
cpp
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 3)
{
cout << "Stack(size_t capacity = 3)" << endl;
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
cout << "~Stack()" << endl;
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
//申请一个在堆上的栈对象：
Stack* p = new Stack;
delete p;
return 0;
}
在栈上开辟了一个空间p，指向在堆上开辟的空间，然后构造成员变量，这时候_array指向一个数组空间，所以在我们delete时，要先析构_arrey的资源，否则如果先清理掉对象空间后，编译器就找不到这个对象资源了。
完整示意图：
定位new表达式(placement-new)
概念：
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象
用法：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
示例：
cpp
int main()
{
A* p = (A*)malloc(sizeof(A));
new(p)A;
p->~A();
return 0;
}
这是显式调用构造和析构函数，如果不显示调用，是不会去自动调用的。
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。