🔑🔑博客主页：阿客不是客

🍓🍓系列专栏：从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);
}

回答问题：

选择题：
 
    选项: A.栈 B.堆 C.数据段 D.代码段
 
    globalVar在哪里？____    staticGlobalVar在哪里？____
    staticVar在哪里？____    localVar在哪里？____
    num1 在哪里？____
 
    char2在哪里？____        *char2在哪里？___
    pChar3在哪里？____       *pChar3在哪里？____
    ptr1在哪里？____         *ptr1在哪里？____

🔑 答案：CCCAA  AAADAB

• globalVar在哪里？C staticGlobalVar在哪里？C
  • 解析：globalVar为全局变量放在数据段(静态区)，staticGlobalVar也是全局变量放在数据段(静态区)。两者之间主要区别在：普通全局变量作用于整个代码，可被其他文件访问或修改。而被static修饰的静态全局变量只作用于当前文件，其他文件不可见。
• staticVar在哪里？C localVar在哪里？A
  • 解析：被static修饰的局部变量staticVar放在静态区，普通的局部变量localVar放在栈区。两者之间主要区别在：被static修饰的局部变量的生命周期只会在程序结束后结束，而普通的局部变量的生命周期出了当前作用域就会结束。
• num1 在哪里？A
  • 解析：num1也是一个局部变量，放在栈区。
• char2在哪里？A *char2在哪里？A
  • 解析：char2也是一个局部变量，放在栈区，常量字符串"abcd"放在代码段(常量区)，数组开辟的空间放在栈区。在数组开辟时，常量字符串中字符会被一个一个拷贝进入数组，而数组名是首元素地址，所以*char2得到数组第一个元素，放在栈区。
• pChar3在哪里？A *pChar3在哪里？D
  • 解析：char2也是一个局部指针变量，指向一个放在代码段(常量区)的常量字符串"abcd"。所以*pChar3得到常量字符串的第一个字符，放在代码段(常量区)。
• ptr1在哪里？A *ptr1在哪里？B
  • 解析：ptr1是一个局部指针变量，放在栈区。而其指向的内存区域是由动态内存开辟的，所以*ptr1放在堆区。

① 栈区（stack）

 栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的，用于静态内存分配。执行函数时，函数内部局部变量的存储单元都可以在栈上创建。函数执行结束后这些存储单元会被自动释放。栈内存分配运算内置于处理器的指令集中，拥有很高的效率，但是分配的内存容量是有限的。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

② 堆区（heap）

堆用于程序运行时动态内存分配，堆是可以上增长的。一般由程序员自主分配释放，若程序员不主动不释放，程序结束时可能由操作系统回收。其分配方式类似于链表。

③ 数据段（data segment）

静态存储区，数据段存放全局变量和静态数据，程序结束后由系统释放。

④ 代码段（code segment）

可执行的代码 / 只读常量。代码段存放类成员函数和全局函数的二进制代码。一个程序起来之后，会把它的空间进行划分，而划分是为了更好地管理。函数调用，函数里可能会有很多变量，函数调用建立栈帧，栈帧里存形参、局部变量等等。

二、C语言中动态内存管理

malloc / calloc / realloc 的区别？

malloc是直接开辟空间，calloc在开辟空间的时候需要进行初始化，realloc是调整空间大小，在C语言专题里面已经有所讲解：深入C语言：动态内存管理魔法

三、C++中的动态内存管理

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

3.1 使用new开辟空间

3.1.1 开辟空间

💬 代码演示：

void Test_CPP()
{
    // 动态申请一个int类型的空间
    int* p1 = new int;
 
    // 动态申请一个int类型的空间并初始化为10
    int* p2 = new int(10);
 
    // 动态申请10个int类型的空间
    int* p3 = new int[10];
}

 是不是非常的爽，而且 new 不需要强制类型转换。 

3.1.2 初始化

 C++ 98 并不支持初始化 new 数组，但 C++11 允许大括号初始化，我们就可以用 { } 列表初始化：

int* p1 = new int[5]{1,2}         // 1 2 0 0 0
int* p2 = new int[5]{1,2,3,4,5};  // 1 2 3 4 5

3.2 使用delete释放空间

C 语言用完吗 malloc 之后我们要用 free 函数释放，但是在 C++ 里，我们可以用它配套的 delete 来释放空间！

💭 代码演示：使用 delete 释放空间

void Test_CPP()
{
    int* p1 = new int;
    int* p2 = new int(10);
    int* p3 = new int[10];    // 多个对象
    
    // 单个对象，delete即可。
    delete p1;
    delete p2;
 
    // 多个对象，delete[] 。
    delete[] p3;
}

3.3 new 和 delete 操作自定义类型

我们知道了，malloc / free 和 new / delete 对于内置类型没有本质区别，那么它存在的意义是什么呢？仅仅是因为用法更简洁吗？当然不是，我们继续往下看。

诚然，对于自定义类型，你也是可以用 malloc 的。

💬 代码演示：用 malloc 创建对象

#include <iostream>
using namespace std;
 
class A {
public:
	A()
		: _a(0) {
		cout << "A():" << this << endl;
	}
	~A() {
		cout << "~A():" << this << endl;
	}
 
private:
	int _a;
};
 
int main(void)
{
	// 动态申请单个A对象和5个A对象数组
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = (A*)malloc(sizeof(A) * 5);
}

对于这种是自定义类型的场景，你继续坚持用 C 语言的动态内存开辟的手段。这当然是行的，没人会拦你，但是我们在来看看 C++ 的：

int main(void)
{
	// 动态申请单个A对象和5个A对象数组
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = (A*)malloc(sizeof(A) * 5);
 
	A* p3 = new A;     // 后面只需要跟类型就可以
	A* p4 = new A[5];
}

直接看代码，同样是申请单个 A 对象和 5 个对象数组，C++ 写法明显是是更简单。仅仅是因为如此吗？我们再调试调试一睹芳容！

从这里我们就知道：new创建自定义类型时会自动调用其构造函数，不仅能开内存，还能帮你初始化！是的！如果是一个数组，new 也会对它初始化。比如这里的 new A[5] ，它会依次对动态创建的 5 个对象进行初始化

💬 我们来对比一下 free 和 delete，它们都是用来释放内存空间的。

与new和malloc的区别类似，free 只是把 p1 p2 指向的空间释放掉，而 delete 不仅会释 p1 p2 指向的空间，delete 还会调用对应的析构函数。

3.4 new/delete 和 malloc/free 要匹配使用

new     👉  delete 
new[]   👉  delete[] 
 
malloc  👉  free(A)

 new 对应的是 delete，可以可以 new 出来的用 free 释放？

💡 不建议大家混着用， new 出来的用 free，有的时候编译器就会发生崩溃，例如使用析构函数，会在数据之前存储数据的个数，这种情况之下二者是不兼容的。

不仅如此，new[] 出来的 你去 delate 而不是 delate[]  也会崩：

int main(void)
{
	A* p4 = new A[5];
	delete p4;	      // delete[] p4;     
}

记住一个点就可以了：壹壹对应，匹配使用，就不会翻车

四、new 和 delete 的底层原理

4.1 operator new 与 operator delete 函数

new 和 delete 是用户进行动态内存申请和释放的操作符，而operator new 和operator delete是系统提供的全局函数，并且operator new和operator delete也不是对new和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来释放空间的。

• 通过观察我们发现operator new与operator delete函数对于自定义类型一样不会调用其构造函数与析构函数。

面向过程的语言处理错误的方式：返回值 + 错误码解决（这个我们之前学过，比如C语言）。

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    char* p1 = (char*)malloc(1024u * 1024u * 1024u *2u);
    if (p1 == nullptr) {
        printf("%d\n", errno);
        perror("malloc fail");
        exit(-1);
    } else {
        printf("%p\n", p1);
    }
 
    return 0;
}

而面向对象语言处理错误的方式：一般是抛异常，C++中也要求出错抛异常 —— try catch（后期会细说）。

🔺 C++ 提出 new 和 delete，主要是解决两个问题：

• 自定义类型对象自动申请的时候，初始化和清理的问题。new / delete 会调用构造函数和析构函数，可以更好地服务于面向对象。
• new 失败了以后要求抛异常，这样才符合面向语言的出错处理机制。（delete 和 free 一般不会失败，如果失败了，都是释放空间上存在越界或者释放指针位置不对）

五、new 和 delete 的实现原理

5.1 内置类型

如果申请的是内置类型的空间，new 和 malloc，delete 和 free 基本相似。不同的地方是，new / delete 申请和释放的是单个元素的空间，

new[] 和 delete[] 申请的是连续空间，而且 new 再申请空间失败时会抛异常。

A* p3 = new A;      // 开辟单个空间
A* p4 = new A[5];   // 开辟的是连续地5个空间

operator new 和 operator delete 就是对 malloc 和 free 的封装。operator new 中调用 malloc 后申请内存，失败以后，改为抛异常处理错误，这样符合 C++ 面向对象语言处理错误的方式。

5.2 自定义类型

new 的原理：

① 调用 operator new 函数申请空间。

② 在申请空间上执行构造函数，完成对象的构造。

delete 的原理：

① 在空间上执行析构函数，完成对象中资源的清理工作。

② 调用 operator delete 函数释放对象的空间。

new T[N] 的原理：

① 调用 operator new[] 函数，在 operator new[] 中实际调用 operator new 函数完成 N 个对象空间的申请。

② 在申请的空间上调用 N 次构造函数，对它们分别初始化。

Stack* p1 = new[10];
Stack* pst1 = (Stack*)operator new[](sizeof(Stack) * 10);

delete[] 的原理：

① 在释放的对象空间上执行 N 次析构函数，完成 N 个对象中资源的清理。

② 调用 operator delete[] 释放空间，实际在 operator delete[] 中调用 operator delete 来释放空间。

六、定位new

如果不用 new，我想手动调用构造函数初始化，我们该怎么做？假设我们这有一块空间，是从内存池取来的，或者是 malloc 出来的、operator new 出来的……

我就不想用 new，但是我想对他进行初始化，行不行？

当然可以！定位 new 表达式 帮你！

6.1 定位 new 表达式

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

简单来说就是，定位 new 表达式可以在已有的空间进行初始化。

📚 写法：分为带参和不带参形式

new(目标地址指针)类型                         // 不带参
new(目标地址指针)类型(该类型的初始化列表)       // 带参

📌 注意：目标地址必须是一个指针

6.2 定位new的使用场景

定位 new 是很有用的！比如开的空间是从内存池来的，如果想初始化，我们就可以使用它。

因为内存池分配出的内存初始化，所以如果是自定义类型的对象，需要使用 new 定义的表达式进行显示调用构造函数进行初始化。

七、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在释放空间前会调用析构函数完成空间中资源的清理。