【C++】C/C++内存管理

在之前C语言的学习中，我们学过了C是如何进行动态内存管理的，也简单的了解过C/C++程序的内存开辟。
这篇文章呢，我们重点来学习一下C++的内存管理方式。

1. C/C++内存分布

C/C++的内存分布我们在之前也是了解过的，那我们这里再简单复习一下。

我们先来看下面的一段代码和一些相关的问题：

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{static int staticVar = 1;int localVar = 1;int num1[10] = { 1, 2, 3, 4 };char char2[] = "abcd";const char* pChar3 = "abcd";int* ptr1 = (int*)malloc(sizeof(int) * 4);int* ptr2 = (int*)calloc(4, sizeof(int));int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);free(ptr1);free(ptr3);
}

问：

我们来分析一下：

首先globalVar是一个全局变量，staticGlobalVar 是一个静态全局变量，staticVar 是静态局部变量，都在静态区（数据段）。
然后localVar 是个局部变量，num1是个整型数组，那它们是在栈上的。

接着看

char2应该在哪？🆗，这里涉及到我们之前C语言讲过的一个关于常量字符串的知识，我们先来复习一下：

相信现在大家就知道了，char2这个字符数组还是在栈上的，只是拿代码段（常量区）的一个常量字符串去初始化它了，然后*char2，char2是数组首元素地址，那*char2就是数组首元素，还是在栈上。
再看pChar3是一个局部指针变量，在栈上，但是pChar3指向常量区的一个常量字符串，所以 *pChar3是在常量区。
然后ptr1还是局部指针变量，在栈上，ptr1指向的空间是malloc出来的，在堆上。
所以，答案是这样的：

再看几个填空题：

sizeof(num1)，数组名放到 sizeof里面代表整个数组，num1是10个元素的整型数组，所以答案是40； sizeof(char2)， char2里面有5个字符（字符串隐藏结束标志\\0），所以是5； strlen(char2)求字符串长度，是4 ； sizeof(pChar3)，指针变量，大家为4或8字节； strlen(pChar3)，同样求长度是4； sizeof(ptr1)，指针变量，4或8 字节。

最后，再来复习一下C/C++的内存区域划分：

2. C的动态内存管理方式

那我们再来简单复习一下C语言的内存管理方式：

void Test()
{int* p1 = (int*)malloc(sizeof(int));free(p1);// 1.malloc/calloc/realloc的区别是什么？int* p2 = (int*)calloc(4, sizeof(int));int* p3 = (int*)realloc(p2, sizeof(int) * 10);// 这里需要free(p2)吗？free(p3);
}

大家回忆一下，malloc和calloc的区别是什么？
它们都可以在堆上开辟内存空间，除了传参不一样之外，两者的区别在于calloc会把开辟出来的空间全部初始化为0，而malloc不会去初始化。
然后realloc是用来扩容的，有两种方式，原地扩和异地扩。
这里就不细说了，如果大家遗忘了，可以看一下之前的文章链接: link

3. C++内存管理方式

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

3.1 new/delete操作内置类型

在C语言中：

我们使用malloc/calloc去申请空间，是不是需要自己计算需要开辟空间的大小，然后传参，返回值呢是void*，还需要我们自己强转。
int* pp1 = (int*)malloc(sizeof(int));

那在C++中，我们就可以这样：

int* p1 = new int;
直接用一个操作符叫做new，我们也不需要sizeof计算大小，直接给类型就行了，而且也不需要强制类型转换。

如果要动态申请10个整型大小的空间：

直接这样就可以了。

🆗，那大家思考一下：

C++搞出来这样新的动态内存管理的方式，仅仅是为了用起来比C语言方便，简洁一点吗？
那他会不会进行一些优化，比如，C++里这样搞会对空间进行初始化？

好的，并没有初始化。
那这样看的话，C++搞出new这些东西和C语言的malloc这些对于内置类型的操作好像除了用法之外也没有什么很大的区别。
那所以呢？
C++搞出这些东西更多的是为了自定义类型，那new和delete操作自定义类型我们后面也会专门讲解，先不急。

那另外：

我们malloc的时候由于可能会开辟失败的缘故，所以我们一般malloc之后会进行一个检查，如果返回的是空指针，就代表开辟失败。
那我们的new有没有可能失败呢？
当然也是有可能的，但是new失败不是返回空指针，而是抛异常，那关于异常我们后面也会讲到。

然后呢：

我们看到上面对于内置类型new出来的空间并没有被初始化，但是C++其实有方法去对new出来的空间进行初始化。

怎么做呢？

直接在后面加圆括号然后放上我们要初始化的值就行了

要注意与这样写的区别：

那对于我们使用new动态开辟的数组，我们可以初始化吗？
也是可以的：

直接在后面跟大括号进行初始化。

那除了new这个操作符之外呢，我们再来学一个操作符叫做delete：

我们C语言阶段使用malloc/calloc在堆上开辟出来的空间使用完是不是要使用free释放啊。
那如果是我们new出来的空间呢，我们说new和delete操作符也是进行动态内存管理的，所以new出来的空间也是堆上的，那new出来的空间使用完我们要怎么释放呢？
🆗，用一个操作符叫做delete：

不用加括号，因为我们今天学的new和delete是操作符，而malloc/calloc是库里面的函数。
那使用new动态开辟的数组怎么销毁呢？

注意delete后面加一个方括号。

那大家可能会想：

既然都是申请空间和释放空间，那可以不可以混起来用呢？
就是malloc的空间可不可以不 free ，而使用delete ，new 出来的空间去free，或者是其它方式的混用。
🆗，那想告诉大家的是：
申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]
注意：匹配起来使用。
我们不要去不匹配的用，不匹配的话，有些情况可能没事，但是有些情况下可能就出错了。
至于原因我们后面也会浅浅的给大家解释一下。

3.2 new和delete操作自定义类型

那我们上面提到：C++搞出new和delete这些东西更多的是为了自定义类型，那接下来我们就来看一下new和delete操作自定义类型有什么特别的地方。

那现在有这样一个自定义类型类A：

class A
{
public:A(int a = 0): _a(a){cout << "A():" << this << endl;}~A(){cout << "~A():" << this << endl;}
private:int _a;
};

那大家看：

这两种写法有什么区别吗？

我们看到用malloc呢就只是开辟了空间。
但是用new呢？

除了开辟空间还自动调用了构造函数进行初始化。

free只是释放了空间；
delete除了释放指针指向的空间还会调用析构函数对自定义类型进行析构。

当然：
如果对应的构造函数有参数，我们new的同时也可以传参：

所以：

在申请和释放自定义类型的空间时，new会自动调用构造函数，delete会自动调用析构函数，而malloc与free不会。

4. operator new与operator delete函数

接下来我们来了解一点底层的东西，看两个函数—— operator new与operator delete

首先要说明一点：

虽然这两个函数的函数名是operator 操作符，但是， operator new与operator delete并不是 new 和 delete的重载，而且我们之前学过重载operator和操作符之间是没空格的。
operator new与operator delete是库里面的两个全局的函数。

那它们两个和我们今天讲的内容有什么关系呢？

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

那 operator new与operator delete底层又是如何实现的呢？

我们可以简单看一下它们的源代码：

可以看到，operator new实际也是借助malloc来申请空间的，申请成功直接返回，申请失败则抛异常。
然后来看一下operator delete：

operator delete实际也是利用free来释放空间的。

通过上述两个全局函数的实现知道：

operator new 实际也是通过malloc来申请空间，如果
malloc申请空间成功就直接返回，否则执行用户提供的空间不足的应对措施，如果用户提供该措施就继续申请，否则就抛异常。
operator delete 最终也是通过free来释放空间的。
可以认为 operator new与operator delete本质是对malloc和free的一个封装。
而我们的new和delete其实在底层又是去调用 operator new与operator delete去完成动态内存的申请和释放的。

那大家想一下：

为什么new和delete不直接去使用malloc和free实现呢，中间又搞出来一层 operator new与operator delete呢？
🆗，我们知道C++是一门基于面向对象的编程语言，面向对象的编程语言在发生错误时一般都是抛异常的，而C语言这些malloc函数发生错误时是不是都不会抛异常啊，像malloc如果申请失败是返回空指针，是不是不满足需求啊，所以，这里用 operator new与operator delete对malloc和free进行了一个封装。
以此来满足在C++里的一些需求。

当然，与A* p3 = new A[10];这种场景匹配，还有operator new[]和operator delete[]

然后operator new[]里面其实还是调operator new

5. new和delete的实现原理

5.1 内置类型

如果申请的是内置类型的空间，new和malloc，delete和free可以认为区别不是很大。
需要注意的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间。
new在申请空间失败时是抛异常，而malloc是返回NULL。

5.2 自定义类型

1. new的原理

1. 调用operator new函数申请空间，operator new实际又调用malloc
2. 在申请的空间上执行构造函数，完成对象的构造

2. delete的原理

1. 在要释放的对象空间上执行析构函数，完成对象中资源的清理工作
2. 调用operator delete函数，operator delete实际调free释放对象的空间

3. new T[N]的原理

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
2. 在申请的空间上执行N次构造函数

4. delete[]的原理

1. 在要释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

🆗，那了解了这些东西，我们其实就可以简单的理解一下上面提到的一个问题了：

那为什么不匹配的话，有些情况没事，有些情况就出问题了呢？

比如说我们new一个自定义类型，那正常情况下我们应该使用delete去释放，那如果我们用free，可能会出现什么问题？
我们来分析一下：
我们知道对于自定义类型delete是会去调用析构函数的，然后再去释放对象在堆上的空间；所以如果我们用free的话，相当于没有对对象进行析构，那自定义类型不析构，一定会有问题吗？
是不是要看情况啊，如果类中不存在资源申请（比如我们之前实现的日期类），是不是不析构也不会有什么问题；但如果类中存在资源申请（栈Stack类），那我们不析构的话是不是就内存泄漏了啊。
所以我们一定要匹配的使用，要不然有些情况下就出现问题了。
但是呢？内存泄漏我们知道是检测不出来的，并不会直接报错。

那在有些场景下如果我们不匹配使用是会报错的：

我们还来看这个类：

class A
{
public:A(int a = 0): _a(a){cout << "A():" << this << endl;}~A(){cout << "~A():" << this << endl;}
private:int _a;
};

然后我们来new一个10个对象大小的数组，在这种场景下，我们试一下会发现，不论我们用free还是delete，只要不匹配，运行都会出错：


只有我们用delete[]才没事：

首先我们用free的话是没有调析构函数的，用delete只调一次，但是我们这里10个对象，析构应该调10次的。
但是呢？这些都不是报错的真正原因，我们上面说过了，没调析构函数，即使内存泄漏也不会报出来的。

那这里程序之所以会崩溃报错其实是跟编译器的实现机制有关系：

大家有没有发现我们new的时候传了一个10告诉编译器我们要申请10个对象大小的空间，但是我们delete[]的时候并没有指定个数，编译器怎么知道应该析构10次呢？
🆗，那我们的编译器呢有一种机制，当然我是以我们现在使用vs来说的，那它会怎么做呢？
拿我们当前的程序来说，我们new了一个10个对象的数组，我们一个A对象4个字节，所以应该开40个字节的空间，但是呢，编译器在这里会多开4个字节空间来专门存储这个对象个数10，存起来就是为了delete[]的时候用。
那这样的话：

那我们现在去free的时候，指针位置是不是不对啊，这才是真正出错的原因，因为free必须给的是指向空间起始位置的指针。
那delete[]为什么就没事呢？
它呢会从返回的位置向前减4个字节然后取到存起来的对象个数，那它就知道要调用几次析构函数了，然后释放的时候呢，它会从当前位置向前偏4个字节去释放。
所以说，这种情况一定要匹配使用。
当然并不是所有的编译器都会这样做，我们现在说的是在我们目前用的vs上。

那再给大家说一个东西：

刚才我们用delete和free程序不是都崩溃了嘛，那我们现在做这样一件事：

把析构函数注释掉。然后：

我们发现delete就不报错了。
为什么呢？
🆗，那原因就在于我们把析构函数屏蔽掉了，那编译器呢很聪明，它识别了一下发现我们没有写析构函数，默认生成的不调好像也无所谓，那这时它就不会再多开前面的4个字节了，所以这次程序没有崩溃。

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

我们再来总结一下 malloc/free和new/delete的区别：

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

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

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

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

举个栗子：

class A
{
public:A(int a = 0): _a(a){cout << "A():" << this << endl;}~A(){cout << "~A():" << this << endl;}
private:int _a;
};

还是这样一个类A。

通过之前的学习我们知道这样直接拿A定义一个对象它是会自动调用构造函数进行初始化的。

但如果这样呢？

这里我们malloc出一个A，然后强转为A*，那这样做这里是不会对这块空间初始化的：

那如果现在我们想在这块已经开辟出来的空间对指针p1指向的对象初始化，要怎么做呢？
那我们就可以使用定位new来搞：
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type或者
new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是参数列表
那我们想给当前p1指向的对象初始化就可以这样：

因为类A的构造函数我们给了缺省值，所以这里我们可以自己传参也可以不传使用缺省值。

但是呢：

我们可能会觉得这个定位new好像没什么意义，我们直接new一个对象出来他不就自动调用构造函数了，为啥非得再去用定位new去初始化呢，没必要啊。
确实是这样的，但是在某些特定场景下，是需要使用定位new的：
定位new表达式在实际中一般是配合内存池使用。
因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用定位new显式调用构造函数进行初始化。

🆗，那这篇文章的内容呢就到这里，欢迎大家指正！！！