C++ 初阶篇 动态内存管理

前言

本文围绕 C/C++ 内存管理核心知识点，从分区、分配机制、实战对比到避坑技巧，帮开发者系统性掌握精髓，规避内存泄漏等常见问题。

一、C/C++ 内存分布

1.1介绍

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

1. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的（先使用高地址的内存）。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（现在只需要了解一下，后续Linux会讲到）
3. 堆用于程序运行时动态内存分配，堆是可以上增长的（先使用低地址的内存）。
4. 数据段–存储全局数据和静态数据。
5. 代码段–可执行的代码（逻辑代码）/只读常量。

注：虚拟进程地址空间、多进程多线程以及操作系统内核等相关知识我们会在 Linux 中进行学习，这里我们只需要学习 C/C++ 的内存区域划分即可。

1.2题目

在学习了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在哪里？C staticGlobalVar在哪里？C
staticVar在哪里？C localVar在哪里？A
num1 在哪里？A
【分析】:
globalVar全局变量在数据段
staticGlobalVar静态全局变量在静态区
staticVar静态局部变量在静态区
localVar局部变量在栈区
num1局部变量在栈区
char2在哪里？A *char2在哪里？A
pChar3在哪里？A *pChar3在哪里？D
ptr1在哪里？A *ptr1在哪里？B
【分析】:
char2局部变量在栈区
char2是一个数组，把后面常量串拷贝过来到数组中，数组在栈上，所以*char2在栈上
pChar3局部变量在栈区
*pChar3得到的是字符串常量字符在代码段
ptr1局部变量在栈区
*ptr1得到的是动态申请空间的数据在堆区

填空

sizeof(num1) = 40; //数组大小,10个整形数据一共40字节
sizeof(char2) = 5; //包括\0的空间
strlen(char2) = 4; //不包括\0的长度
sizeof(pChar3) = 4; //pChar3为指针
strlen(pChar3) = 4; //字符串“abcd”的长度，不包括\0的长度
sizeof(ptr1) = 4; //ptr1是指针

简答题
malloc/calloc/realloc的区别？

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

这里需要free(p2)吗？

void Test ()
{ 
    int* p2 = (int*)calloc(4, sizeof (int));
    int* p3 = (int*)realloc(p2, sizeof(int)*10);
    free(p3 );
    
}

不需要free(p2)，无论是异地扩容还是原地扩容，最终都不需要专门释放p2，如果是原地扩容，p1和p2指向同一块空间，如果是异地的话，将原内容拷贝后会自动释放原来p2指向的空间

栈与堆对比

二、C++动态内存管理方式

2.1引入

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

2.2C/C++的使用

1. C语言：malloc/calloc/realloc与free

• malloc(size_t size)：分配指定字节数的堆内存，返回 void * 指针，需手动类型转换。
• calloc(size_t num, size_t size)：分配 num 个大小为 size 的连续内存，初始化为 0。
• realloc(void* ptr, size_t size)：调整已分配内存的大小，可能会移动内存块。
• free(void* ptr)：释放通过上述函数分配的堆内存，ptr 必须指向堆内存起始地址。

#include <stdio.h>
#include <stdlib.h>
 
int main() 
{
    // 1. malloc：分配内存（不初始化）
    int* m = (int*)malloc(2 * sizeof(int));
    m[0] = 1; m[1] = 2;
    printf("malloc: %d, %d\n", m[0], m[1]);
 
 
    // 2. calloc：分配并初始化为0
    int* c = (int*)calloc(2, sizeof(int));
    printf("calloc: %d, %d\n", c[0], c[1]);
 
 
    // 3. realloc：扩容malloc的内存
    m = (int*)realloc(m, 3 * sizeof(int));
    m[2] = 3;
    printf("realloc后: %d, %d, %d\n", m[0], m[1], m[2]);
 
 
    // 4. free：释放内存
    free(m);
    free(c);
    return 0;
}

2. C++：new/delete与new[]/delete[]

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;
}

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

三、区别

3.1new/delete 操作内置类型

对于内置类型，C语言和C++内存管理方式没有明显区别，只是C++中使用 new 操作符来替代C语言中的 malloc/calloc 函数，使用 delete 操作符来替代 free 函数 ；
同时，由于 new 和 delete 是操作符/关键字，而不是函数，所以它们后面不需要跟括号，而是直接跟类型即可；另外，new 可以在开辟空间的同时进行初始化。

3.2new/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;
};


int main()
{
	A* p1 = new A(1);
	delete p1;
	cout << endl;
	A* p2 = new A[2];//生成2个A对象
	delete[] p2;
    return 0;
}

new T：分配单个 T 类型对象的内存，自动调用构造函数初始化。
new T[n]：分配 n 个 T 类型对象的数组内存，自动调用每个对象的构造函数。
delete ptr：自动调用析构函数，释放单个对象内存。
delete[] ptr：自动调用每个对象的析构函数，释放数组内存。

• 注意

• 接口必须成对使用，new对应delete，new[]对应delete[]，混用会导致内存泄漏或程序崩溃。
• 无需手动类型转换，new返回对应类型指针，且分配失败时抛出bad_alloc异常（而非返回 NULL）。

四、深入 new 与 delete

4.1引入operator new 和 operator delete

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

需要特别注意的是，operator new 和 operator delete 函数不是运算符重载，因为它们的参数没有自定义类型，而是库里面实现的全局函数，仅仅是将它们取名为 operator 而已，很多C++的初学者都会被二者的函数名所误导。

4.2源码区别

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)

• 通过上述的实验我们知道 operator new 实际也是通过 malloc 来申请空间，如果 malloc
  申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供了该措施就继续申请，否则就抛异常。operator delete
  最终是通过 free 来释放空间的。

4.3汇编区别

【new底层汇编】

从图中可以看到是先调用operator new，再调用相对应的构造函数
【delete底层汇编】
delete的底层是先调用析构函数，然后再调用operator delete
为什么会怎样呢我们先了解一下下面这个
【模拟栈对象如何在堆上申请/释放空间】

先为栈对象开空间，然后调用该对象的构造函数为_array开辟空间，最终让栈上的p1指针指向堆上的对象（栈对象和栈内存区域是两个不同领域的概念）

释放空间的话要先调用析构函数，如果你先调用operator delete了，_array就成野指针了，就会造成内存泄露

五、定位 new 表达式 (了解)

5.1定位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* pa = (A*)malloc(sizeof(A));

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

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

5.2使用场景

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

简单理解一下内存池：

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

上述例子中全村公用的水井就相当于堆，其他村民排队打水就相当于 malloc/calloc/realloc 函数向堆区申请空间，而村长家的蓄水池就相当于我们的主角 – 内存池，内存池的建立可以使得我们申请空间的效率变得很高。

七总结问题

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

2. 什么是内存泄漏

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况；内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费，

3. 内存泄漏的危害

短期运行的程序发生内存泄露危害不大，因为当程序结束时动态申请的空间全部都会被回收；长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

4. 如何避免内存泄漏?

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状 态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。