内存管理

1. C/C++内存分布

在C语言阶段，常说局部变量存储在栈区，动态内存中的数据存储在堆区，静态变量存储在静态区（数据段），常量存储在常量区（代码段），其实这里所说的栈区、堆区、静态区以及常量区都是 虚拟进程地址空间 的一部分，其中具体内存区域的划分如下：

【说明】：

• 栈：又叫堆栈，用于存储非静态局部变量、函数参数以及函数返回值等等；栈是向下增长的。
• 堆：用于程序运行时进行动态内存分配；堆是向上增长的。
• 数据段 (静态区)：Linux 中通常叫作数据段，用于存储存储全局数据和静态数据。
• 代码段 (常量区)：Linux 中通常叫作代码段，用于存储可执行的代码指令和只读常量。
• 内存映射段：是一种高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，实现进程间通信；
• 内核空间：操作系统内核 – kernel，受硬件保护，用户不能进行读写，用于执行各种机器指令。

注意：虚拟进程地址空间、多进程多线程以及操作系统内核等相关知识会在 Linux 中进行学习，这里只需要了解 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);
}

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

2. 填空题：
sizeof(num1) = ____;
sizeof(char2) = ____;    strlen(char2) = ____;
sizeof(pChar3) = ____;   strlen(pChar3) = ____;
sizeof(ptr1) = ____;

3. sizeof 和 strlen 区别？
    
答案：(横向)
1、选择题：C C C A A A A A D A B
2、填空题：40 5 4 4/8 4 4/8
3、sizeof是操作符/关键字，后面可以不加括号，而直接跟类型，另外，sizeof计算的是变量所占空间的字节数；而strlen是函数，调用必须加括号，且strlen计算的是字符串中字符的个数(不包括'\0')

易错点：

• sizeof(数组名) 的含义是计算整个数组的大小。
• *char2 和 *char2 的存储区域：
  • 对于 char2 中的内容是一个常量字符串 abcd 不可以修改存在放在常量区，但是此处的 char2 是一个数组，数组在栈区上开辟空间，本质 char2 中的数据是从常量区中拷贝而来的，所以 char2 在栈区。
  • 对于 *char2 其实本质是对一个数组名进行解引用，这里的数组名的含义是数组首元素的地址，对数组首元素地址进行解引用之后得到的就是数组中的首元素，但是因为数组首元素就是在栈区，所以 *char2 也在栈区
• pchar3 和 *pchar3 的存储区域：
  • 对于 pchar3 是一个地址指向常量区的 abcd ，但是针对 pchar3 本身来说它就是一个局部变量，所以 pchar3 在栈区
  • 对于 *pchar3 是对 pchsr3 进行解引用，得到的就是 abcd ，但是 abcd 在常量区，所以 *pchar3 就在**常量区（代码段）**上

2. C/C++内存管理方式

2.1 C语言内存管理方式

在C语言中使用 malloc/calloc/realloc/free 函数来进行动态内存管理：

void Test()
{
	int* p1 = (int*)malloc(sizeof(int));
	if (p1 == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	int* p2 = (int*)calloc(4, sizeof(int));
	if (p2 == NULL)
	{
		perror("calloc fail");
		exit(-1);
	}

	int* p3 = (int*)realloc(p2, sizeof(int) * 10);
	if (p3 == NULL)
	{
		perror("realloc fail");
		exit(-1);
	}

	free(p1);
    free(p2);
	free(p3);
}

补充：malloc/calloc/realloc的区别？

• malloc 用于开辟一块动态内存，使用时需要指定开辟的空间大小 (字节)，如果开辟成功返回空间的起始地址，如果开辟失败返回 NULL，且不会初始化。
• calloc 的用法和 malloc 类似，只是它有两个参数，第一个参数为元素个数，第二个参数为每个元素的大小，并且它会将该空间中的数据全部初始化为0。
• realloc 用于空间的扩容/缩容，它有两个参数，第一个参数为需要调整的动态内存的起始地址，第二个参数为调整后的空间大小，如果第一个参数为 NULL，则它等价于 malloc；如果扩容，编译器会检查原空间后是否有足够的空间，如果足够，就直接扩容并返回原空间的起始地址，如果不够，就新开辟一块空间，然后将原空间的数据拷贝到新空间并返回新空间的地址，最后再释放原空间；如果缩容，编译器会直接新开辟一块空间，然后拷贝原空间数据到新空间并返回新空间的地址，再释放原空间。

2.2 C++动态内存管理方式

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

2.2.1 new/delete 操作内置类型

对于内置类型，C语言和C++内存管理方式没有明显区别，只是C++中使用 new 操作符来替代C语言中的 malloc/calloc 函数，使用 delete 操作符来替代 free 函数 ；

同时，由于 new 和 delete 是操作符/关键字，而不是函数，所以它们后面不需要跟括号，而是直接跟类型即可。另外，new 可以在开辟空间的同时进行初始化。

注意：C++不支持扩容，要扩容都是自己开辟新空间、拷贝数据，然后再销毁原空间。

void Test()
{
	//申请单个空间不初始化
	int* p1 = new int;

	//申请单个空间并初始化
	int* p2 = new int(10);

	//申请连续空间不初始化
	int* p3 = new int[10];

	//申请连续空间并初始化（为初始化的部分会自动由编译器自动初始化）
	int* p4 = new int[10]{ 1,2,3,4,5 };

	//释放单个空间
	delete p1;
	delete p2;

	//释放多个空间
	delete[] p3;
	delete[] p4;
}

注意：申请和释放单个元素的空间，使用 new 和 delete 操作符，申请和释放连续的空间，使用 new[] 和 delete[]，注意二者一定要匹配使用，即不能用 delete 来释放 new[] 开辟的空间。

2.2.2 new/delete 操作自定义类型

C++动态内存管理和C语言动态内存管理最大的不同在于二者对自定义类型的处理：C语言 malloc/calloc/realloc 函数只负责开辟空间，free 函数只负责销毁空间。而C++在申请自定义类型的空间时，new 会调用构造函数，delete 会调用析构函数，完成对应对象的初始化和销毁。

class A
{
public:
    //构造函数
	A(int a = 0)
		: _a(a)
	{
		cout << "A 构造" << this << endl;
	}
    
    //析构函数
	~A()
	{
		cout << "A 析构" << this << endl;
	}
private:
	int _a;
};

**注意：**先调用析构函数再释放空间。

3. operator new 与 operator delete

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

注意： operator new 和 operator delete 函数不是运算符重载，因为它们的参数没有自定义类型，而是库里面实现的全局函数，仅仅是将它们取名为 operator 而已

C++底层的 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);  //此处调用free函数
	__FINALLY
		_munlock(_HEAP_LOCK);  // release other threads
	__END_TRY_FINALLY
		return;
}

// free的实现
#define  free(p)        _free_dbg(p, _NORMAL_BLOCK)

new 和 delete

在实际的编译器中，通过查看反汇编来验证 new 和 delete 的底层调用。下面以开辟内置类型的空间为示例：

int main()
{
	int* p = new int;
	delete p;
    
    return 0;
}

new[] 和 delete[]

而对于new[] 和 delete[] 来说，它们通过调用 operator new[] 和 operator delete[] 函数来实现其功能，但是其实 operator new[] 和 operator delete[] 底层也是调用的 operator new 和 operator delete 函数：

补充：

通过上述的代码知道 operator new 实际也是通过 malloc 来申请空间，那么为什么还需要对 malloc 进行封装成新的 operator new 函数呢？

因为如果 malloc 申请空间成功就返回新空间的首地址，在申请失败的时候就会返回一个空指针。因为C++是一门面向对象的语言，这样的返回值是无法提现出这样的特性。

所以为了完善这里C++提供了一个对 malloc 新封装的函数 operator new 如果内存正常申请即和 malloc 一样，但是如果申请内存失败就会执行用户提供的空间不足的应对措施，如果用户提供措施就继续申请，否则抛出一个 bad_alloc 类型异常，可以在 main 函数中利用 catch 进行捕获，这样的设计就更加符合C++是一门面向对象语言的特点。

同时因为 operator new 和 operator delete 还是内置的去全局函数，也可以在程序中调用。

A* p1 = (A*)operator new (sizeof(A));
operator delete (p1);

同样可以起到开辟空间，销毁空间的目的，但是这样使用就不会调用构造函数和析构函数进行初始化和资源的销毁。但是这样使用又比直接使用 malloc 更加方便，因为其不需要再对新申请的空间进行检查，因为其失败了会抛异常。需要在外层捕获异常。

4. new 和 delete 的实现原理

4. 1 内置类型

如果申请的是内置类型的空间，new 和 malloc，delete 和 free 基本类似，不同的地方是：

• new/delete 申请和释放的是单个元素的空间，new[] 和 delete[] 申请的是连续的空间
• new 在申请空间失败时会抛异常，而 malloc 申请失败则是会返回 NULL。

4.2 自定义类型

• new 的原理
  1. 调用 operator new 函数申请空间。
  2. 在申请的空间上调用构造函数，完成对象的初始化
• delete 的原理
  1. 在空间上执行析构函数，完成对象中资源的清理工作。
  2. 调用 operator delete 函数释放对象的空。
• new T[N] 的原理
  1. 调用 operator new[] 函数，在 operator new[] 中实际调用 operator new 函数完成N个对象空间的申请。
  2. 在申请的空间上调用N次构造函数。
• delete[] 的原理
  1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理。
  2. 调用 operator delete[] 释放空间，实际在 operator delete[] 中调用operator delete来释放空间。

可以看到，对于自定义类型，C++ 中的 new 和 delete 不仅仅会进行空间的申请和释放，还会进行构造和析构，这也正是为什么在C语言已经有了malloc/calloc/realloc/free 的情况下，C++ 又单独创造了 new 和 delete 的原因。

5. 定位 new 表达式（placement - new）

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

其使用格式如下：

new(place_address) type  
new (place_address) type(initializer-list)

其中 place_address 必须是一个指针，initializer-list 是类型的初始化列表。

示例如下：

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

	~A()
	{
		cout << "~A():" << this << endl;
	}

private:
	int _a;
};

int main()
{
    //p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	if (p1 == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	//定位new--对p1指向的空间显式调用构造函数
	new(p1)A(1);

	p1->~A();  //析构函数可以直接显式调用，或者直接使用delete
	free(pa);
}

注意：构造函数在平时的代码中不可以被显示调用，这中使用定位new的方法可以显示调用构造函数。析构函数可以被显示调用，只需要指定好对应对象即可。

这种使用场景其实在平时的开发过程中基本不会使用，因为如上的 main 函数代码就是两行 new 和 delete 就可以解决的事情。所以**定位 new **的使用场景基本在内存池中。

使用场景：

定位 new 表达式在实际中一般是配合内存池使用。

因为内存池分配出的内存对象是没有被初始化的，所以如果是自定义类型的对象，需要使用 new 的定义表达式进行显示调构造函数进行初始化。而内存池在后面会详细学习，此处了解一下即可。

简单理解内存池：

假设半山腰有一个村子，但由于各种原因村子中没有水喝，所以人们每次喝水都只能到山下的公共水井处排队打水，但是呢排队很慢，所以村长就用抽水机+水管联通水井在自己家建了一个蓄水池，以后要用水就直接到蓄水池中去取即可，而不用再到山下去排队打水了，大大提高了效率。

上述例子中全村公用的水井就相当于堆，其他村民排队打水就相当于 malloc/calloc/realloc 函数向堆区申请空间，而村长家的蓄水池就相当于内存池，其实本质也就相当于一次性申请了很大一部分内存供自己的对象本身进行使用，减少了频繁对堆的空间内存申请，内存池的建立可以使得申请空间的效率变得很高。

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

6.1 共同点

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

6.2 不同点

• malloc 和 free 是函数，new 和 delete 是操作符。
• 申请内置类型空间时，malloc 申请的空间不可以初始化，new 可以初始化。
• 申请自定义类型对象时，malloc/free 只会开辟空间，不会调用构造函数与析构函数，而 new 在申请空间后会调用构造函数完成对象的初始化，delete 在释放空间前会调用析构函数完成空间中资源的清理。
• malloc 申请空间时，需要手动计算空间大小并传递，new 只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即。
• malloc 的返回值为 void* , 在使用时必须强转，new 不需要，因为 new 后跟的是空间的类型。
• malloc 申请空间失败时，返回的是 NULL ，因此使用时必须判空，new 不需要，但是 new 需要捕获异常。