C++中的动态内存管理：new/delete
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
new：
用于在运行时动态的分配内存并返回该内存的指针。它可以与数据类型一起使用，以指定要分配的内存大小和类型。例如，int* p = new int;这行代码会分配一个足以存储int类型数据的内存块，并将返回的地址赋值给指针p。
delete：
用于释放由new分配的内存。在C++中，必须显示释放不再需要的内存，以防止内存泄漏。delete运算符接受一个指针作为参数，并释放该指针指向的内存。例如，delete p;这行代码会释放之前由new为p分配的内存。
接下来，我们详细讲讲new和delete的用法。
new和delete操作内置类型
申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]。
下面可以来看一组代码案例：
// 动态申请一个int类型的空间
int ptr1 = new int;
cout << ptr1 << endl;
// 动态申请一个int类型的空间并初始化为10
int ptr2 = new int(10);
cout << ptr2 << endl;
// 动态申请10个int类型的空间
int ptr3 = new int[3];
for (int i = 0; i < 3; i++)
cout << (ptr3 + i) << " ";
cout << endl;
// 动态申请10个int类型的空间，并初始化
int ptr4 = new int[3] {1, 2};
for (int i = 0; i < 3; i++)
cout << (ptr4 + i) << " ";
cout << endl;
delete ptr1;
delete ptr2;
// 释放数组空间delete之后指针之前要加[]
delete[] ptr3;
delete[] ptr4;
以下是此段代码运行结果：
可以看出，单纯的new不会自动给内置类型初始化。所以，如果需要特定的值，需要像ptr2那样给动态申请的空间初始化。
通过ptr3和ptr4的对比，会发现，new同样不会对动态开辟的数组进行初始化，但是可以通过ptr4初始化数组的方式，此时，未被赋值的类型会自动初始化成0。
new和delete操作自定义类型
单纯拿new和delete对内置类型的操作来说，其实与C语言想必并没有什么太大的优势。但是C++中多了类这一个新的内容之后，new和delete就大有用武之地了。在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。 自动调用构造和析构的作用可不小，当你的自定义类型有一个指针指向某一块资源的时候，就非常有必要了。自动调用构造和析构可以帮助你在动态内存管理的过程中自动开辟和释放指对象中的针指向的资源，很大程度上避免了空指针和内存泄露等问题。
下面可以看一段代码案例帮助理解：
include
using namespace std;
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】
// 除了开空间还会调用构造函数和析构函数
A p1 = (A)malloc(sizeof(A));
A* p2 = new A(1);
free(p1);
delete p2;
cout << endl;
// 内置类型是几乎是一样的
int* p3 = (int*)malloc(sizeof(int)); // C
int* p4 = new int;
free(p3);
delete p4;
A* p5 = (A*)malloc(sizeof(A) * 10);
A* p6 = new A[10];// 自动调用10次构造和析构
free(p5);
delete[] p6;
cout << endl;
return 0;
}
注：new和delete需要匹配使用，不要和C语言中的动态内存管理函数交叉，否则运行的结果是未定义的。
operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
我们可以简单来看一下，operator new与operator delete的全局定义：
/
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。 /
void __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
// try to allocate size bytes
void p;
while ((p = malloc(size)) == 0)
if (_callnewh(size) == 0)
{
// report no memory
// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}
/
operator delete: 该函数最终是通过free来释放空间的 /
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); FINALLY
_munlock(_HEAP_LOCK); / release other threads /
__END_TRY_FINALLY
return;
}
/
free的实现 /
define free(p) _free_dbg(p, _NORMAL_BLOCK)
通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
new和delete的实现原理
本质上说，new实际上就是operator new的一个封装，而operator new又是malloc的一个封装；delete实际上就是operator delete的一个封装，而operator delete又是free的一个封装。
内置类型：
如果申请的是内置类型的空间，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来释放空间
定位new表达式(placement-new)
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type 或new(place_address)type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表。
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
下面看一组代码案例：
include
using namespace std;
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
int _a;
};
// 定位new/replacement new使用演示
int main()
{
// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
A p1 = (A)malloc(sizeof(A));
new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
p1->~A();
free(p1);
cout << endl;
A* p2 = (A*)operator new(sizeof(A));
new(p2)A(10);
p2->~A();
operator delete(p2);
cout << endl;
// 当你想创建多个对象，可以考虑使用循环
A* p3 = (A*)operator new(sizeof(A) * 4);
for (int i = 0; i < 4; i++)
new(p3 + i)A(10);
for (int i = 0; i < 4; i++)
cout << (p3 + i)->_a << " ";
cout << endl;
for (int i = 0; i < 4; i++)
(p3 + i)->~A();
cout << endl;
// 要创建多个对象时，也可以这样使用定位new，编译器支持
A* p4 = (A*)malloc(sizeof(A) * 4);
new(p4)A[4] {1, 2, 3};
for (int i = 0; i < 4; i++)
cout << (p4 + i)->_a << " ";
cout << endl;
for (int i = 0; i < 4; i++)
(p4 + i)->~A();
free(p4);
cout << endl;
return 0;
}
运行结果如图：
结语
本篇博客详细讲解了C和C++中动态内存管理的方式，在C语言中，可以使用，malloc，realloc，calloc和free这四个函数进行动态内存管理；在C++中虽然也支持使用C中的四个函数，但新增的new和delete关键字能自动调用自定义类型的拷贝构造函数和析构函数，且开辟或释放失败后不再返回空指针，而是抛异常。我们同样讲到了operator new和operator delete这两个全局函数，它们通过封装能得到我们的new和delete。最后提到了定位new，可以支持给已经开辟的自定义类型空间进行构造或赋值。 关于内存管理的内容还不止于此，在后期的C++11的内容中，会讲到智能指针，内存泄露问题的规避管理等等知识。
博主后续还会产出更多有意思的内容，感谢大家的支持！♥
