C++内存管理
0.C/C++内存分布复习
下面代码只是作为C语言基础复习，您粗浅看一下即可：
#include 1.内存管理
1.1.C语言的的动态内存管理方式
#define SIZE 10
int main()
{
int* arr = (int*)malloc(sizeof(int) * SIZE);
if (arr == NULL)
{
exit(-1);
}
for (int i = 0; i < SIZE; i++)
{
arr[i] = i * i;
printf("%d ", arr[i]);
}
printf("\n");
for (int j = 0; j < SIZE; j++)
{
free(arr + j);
}
return 0;
}
C语言在这方面使用malloc、calloc、realloc、free来管理堆空间，这一套函数在C++中依旧可以使用，但是会有很大的问题。
class Data
{
public:
Data(int x = 10)
{
_x = x;
}
private:
int _x;
};
int main()
{
Data* px = (Data*)malloc(sizeof(Data));
//空间是申请出来了，该怎么调用构造函数呢？
//px->_a = 1;//不可以，成员变量是私有的
//px->Data(1);//不可以，构造函数只能由编译器调用（自动），不可以我们手动调用
return 0;
}
于是C++依旧建立了一套新的方案new和delete。
1.2.C++的操作符new与delete
首先我们来学会使用new和delet，注意：new和delete是操作符，而不是函数。
1.2.1.new/delete操作内置类型
#include 单个元素使用new和delete操作符，多个元素使用new[]和delete[]操作符。
另外C++98不支持进行初始化，但是C++11支持new使用()以及{}初始化，也就是C++11后可以这么写：
#include
C++不支持扩容 ，没有一个类似realloc的操作符。
使用new和delete更加适应自定义类型：
#include 利用C++的new来写一个用来测试的链表简直不要太快：
#include 1.2.2.new/delete操作自定义类型
对于内置类型使用这两个操作符来说，和malloc与free没有什么本质区别。但是在申请自定义类型大小的空间时，就有一些很大的变化了。
#include 调用构造函数和析构函数就是与C语言最大的区别，因此实际上new和delete是为了自定义类型而准备的（这也就是为什么在C++98中一开始没有初始化，这是暗示在使用在自定义类型中需要通过写构造函数来进行初始化，C++98很有可能觉得没有必要添加初始化这一套）。一定要注意析构函数释放的是对象成员所使用的堆资源，而不是释放对象的空间。
1.2.3.new/delete匹配问题
-
new和delet匹配，new[]和delete[]匹配。 -
而
new出来的空间不可以使用free()释放，malloc()出来的空间不可以使用delete释放。
1.3.new失败的解决方案
另外对于申请失败的情况，C与C++也不一样。malloc()失败返回空指针，new失败抛异常。（抛出异常是面向对象语言出错的一种处理方式，相比与C语言的返回错误码更好一些）
而C++处理堆错误的方式如下，有点类似go to的使用：
#include 2.operator new()与operator delete()
new和delete是用户动态申请内存的释放内存的操作符，而operator new()与operator delete()是系统提供的全局函数。
-
new在底层调用operator new()来申请空间，然后在申请的空间上执行构造函数，完成对象的构造。 -
delete在底层先执行析构函数，完成对象中资源的清理，调用operator delete()来释放空间。
注意：这里的
operator只是函数名字的一部分，不是重载关键字，不要误会了。
您可以看一下new和delete调用的汇编代码，内部就调用了这两个全局函数。
2.1.operator new()的源码部分
可以观察到底层也是使用了malloc()函数开空间，并且处理了申请异常部分：
/*
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);
}
另外我们也可以像使用malloc()一样使用operator new()，但是失败还是抛出异常。
2.2.operator delete()的源码部分
可以观察到底层最终也是通过free()来释放空间的：
/*
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)
同样这个全局函数也是可以直接使用的。
吐槽：不过也有不少人吐槽这两个全局函数的名字，和运算符重载实在是很像……
2.3.使用operator new()与operator delete()
实际上这两个函数就是malloc()和free()的封装（为了new和delete准备的）。因此我们直接使用也是可以的。
#include 2.4.重载全局operator new()和operator delete()
在实际使用C++中，我们一般不直接使用这两个全局函数，包括malloc()和free()都很少使用了。
但是有的时候有重载这两个全局函数的需求。
#include 这样就可以方便以后定位内存泄露了（不过也挺少这么干的）。
2.5.重载局部operator new()和operator delete()
有时候频繁申请内存就会造成内存碎片，下面的代码等以后再回来看看就能明白了：
#include 这样每个类都可以使用自己专属的new，这里了解一下就可以，以后再来认真学习。
3.operator new[] ()和operator delete[] ()
另外还有一个operator new[]()和operator delete[]()，这里就不再赘述了。
-
new T[N]调用operator new[]()，在operator new[]()中实际调用operator new()完成N个对象的申请，然后在申请的空间上执行N次构造函数 -
delete[]在释放的对象空间上执行N次析构函数，完成资源清理，然后调用operator delete[]释放空间，实际在operator delete[]中调用operator delete()来释放空间。
因此这里有一个小点需要补充：
#include 上述方式1和方式2是否会造成内存泄露呢？实际上是不会的，因为delete[]内部实际上调用的是operator delete[]，这个函数内部调用的又是operator delete()因此对于内置类型来说，实际上是没有影响的。
真正会出现问题的是内置类型，因为内置类型会调用构造函数和析构函数，导致出现问题。
//以下是VS2022下实验结果
#include
using namespace std;
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A()" << endl;
}
private:
int _a;
};
class B
{
public:
B(int b = 0)
:_b(b)
{
cout << "B()" << endl;
}
~B()
{
cout << "~B()" << endl;
}
private:
int _b;
};
int main()
{
B* p2 = new B[5];
free(p2);//方式1
delete p2;//方式2
//这里p2在申请空间的时候，会多申请一部分空间（有可能是4字节）存储“5”来表示开辟的空间个数。因此申请的空间有部分是需要指针偏移来销毁的。
//然后再调用delete[]的时候，就可以根据这个“5”来调用5次析构函数。
//但是由于直接使用“free()”和“delete”就无法释放这部分用来表示使用多少次析构函数的空间。
//因此真正的问题是指针错位的问题。
A* p1 = new A[5];
free(p1);//方式1
delete p1;//方式2
//这里p2在申请空间的时候，会多申请一部分空间（有可能是4字节）存储“5”来表示开辟的空间个数。因此申请的空间有部分是需要指针偏移来销毁的。
//然后再调用delete[]的时候，就可以根据这个“5”来调用5次析构函数。
//由于这个类没有析构函数，所以有的编译器会很聪明，知道调用的是默认析构函数，就会直接返回指向标识空间的指针
//因此直接返回的指针没有发生错位，不会出现很大的问题。
return 0;
}
//但是换一个编译器极有可能都会奔溃，所以只要匹配使用即可……
还有的时候如果没有匹配，少调用了析构函数会直接造成内存泄漏。
3.1.定位new的使用
在我们定义出来的类中，我们可以发现，构造函数不可以被显式调用，而析构函数却可以（因为可以提前释放资源，而不必等系统自动调用）。
那么如果我们一定要显式使用构造函数呢？这就可以使用定位new来试试了。
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象，下面是定位new的使用格式。
new (指向某空间的指针) type;
new (指向某空间的指针) type(初始化列表);
在定位new中支持显式调用构造函数，使得开发者更加得自由：
#include 或者这么使用：
#include 甚至这里的内存地址指向的空间不一定是堆空间的，也可能是栈空间的。
相当于手动使用了new的过程，这一操作使得内存申请更加自由，也更容易产生内存泄露。
3.2.定位new的场景
有时也认为堆空间的效率不高（在频繁使用），因此可以提前在堆空间申请一个很大的空间，作为内存池管理起来，这个时候定位new就有很大的用处了。
因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定位表达式进行显示调构造函数进行初始化。不过由于我们没有学过内存池，所以我们以后再说……
具体来说，有几个作用：
自定义内存管理：使用定位
new可以让我们在某个特定的内存位置上构造对象，这对于实现自定义的内存管理策略很有用。比如，如果我们想将对象放置在特定的内存池或缓冲区中，就可以使用定位new来构造对象。特殊的内存需求：有时候我们可能需要在已经分配的特定内存块上构造对象，例如与硬件设备进行交互时需要使用特定的内存地址。
对象重用：定位
new可以重新使用已经存在的对象内存，而无需重新分配新的内存。这在一些特殊场景下有效，例如对象池或内存池的实现。
4.两套动态内存管理的区别
在一些C++工程师的面试题目中，经常考察的几个区别就是：进程与线程的区别、malloc/free与new/deleta的区别、指针和引用的区别、TCP与UDP的区别……
其中malloc/free和new/delete的区别可以从两个点入手：语法使用区别、本质功能区别、判空与异常
-
语法定义上：
malloc()和free()是函数，而new和delet是关键字。 -
语法使用上：
malloc()申请空间时需要计算空间的大小并且传递，new只需要根据空间的类型，如果是多个对象则在[]中指定即可。 -
语法使用上：
malooc()的返回值为void*，需要强制转化，而new不需要。 -
语法使用上：
malloc()申请的空间无法初始化，而new申请的空间可以初始化。 -
本质功能：
malloc()只会申请空间，不会进行初始化，new可以借助对象的构造函数初始化。free()只会释放空间，delet在释放对象空间的同时还会调用对象的析构函数，完成资源清理。 -
判空与异常：
malloc()申请空间失败是返回NULL，因此需要判空。而new是抛出异常来被捕获，因此不需要判空。
共同的地方是：都是从堆上申请，并且都需要经过释放。