【C++初阶】一篇手撕内存管理

一，C/C++内存分布

从用途和存储的角度来看，在C/C++程序中有局部数据、静态数据、全局数据、常量数据、动态申请的数据五种主要的数据，各种数据的特点如下：

• 局部数据：随用随创建，存储在栈区，作用域只在局部，生命周期在局部，出了作用域就销毁。
• 静态数据：存储在数据段，作用域只在局部或当前文件，生命周期伴随程序“一生”。
• 全局数据：存储在数据段，作用域在全局，生命周期伴随程序“一生”。
• 常量数据：存储在代码段。
• 动态申请的数据：存储在堆区。

小Tips：这里需要注意char char2[] = “abcd”;，"abcd"是常量字符串，存储在代码段，但是char2只是一个局部域的数组，它会把这个常量字符串拷贝一份，存储在栈区，然后char2是数组名，表示数组首元素的地址，这里表示的就是拷贝过来存储在栈区的字符串的首元素地址，并不是表示代码段中常量字符串的首元素地址。其次，const并不会改变变量的存储区域，因为pChar3是一个局部变量，所以它还是存储在栈区，前面加const修饰，是因为它存的是代码段中常量字符串的首地址。可见只要是在局部创建的变量，只要前面没有加static修饰，那这个变量一定是存储在栈区。

📖总结：

• 栈：又叫堆栈，用于存放非静态局部变量、函数参数、返回值等等，栈是向下生长的。
• 内存映射段：是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。
• 堆：用于程序运行时动态内存分配，堆是向上增长的。
• 数据段：用于存储全局数据和静态数据。
• 代码段：用于存储可执行的代码/只读的常量。

二，C/C++内存管理方式

在学习C语言时，提到的4个内存管理函数malloc、realloc、calloc、free大家还记得嘛👀？忘了的话可以走传送门，回去看看。在C++中我们任然可以使用C语言中的内存管理方式，但有些地方就无能为力了，而且使用起来比较麻烦，因此C++中提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

2.1 new和delete操作内置类型

void Test()
{
  // 动态申请一个int类型的空间
  int* ptr4 = new int;
  
  // 动态申请一个int类型的空间并初始化为10
  int* ptr5 = new int(10);
  
  // 动态申请10个int类型的空间，不初始化
  int* ptr6 = new int[10];
  // 动态申请10个int类型的空间，并初始化前三个
  int* ptr7 = new int[10]{1,2,3};
  delete ptr4;
  delete ptr5;
  delete[] ptr6;
  delete[] ptr7;
}

小Tips：new对内置类型来说，和C语言一样，只是纯粹的开空间，对于动态申请到的空间，如果不进行人为初始化的话，里面存的都是随机值。动态申请并初始化，类型后面跟的是圆括号()，动态申请多个连续空间，类型后面跟的是方括号[]，如果要对这多个连续的空间初始化，可以在[]的后面跟{}，里面是初始化的数据，可以只初始化一部分，后面默认补0。申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间使用new[]和delete[]。

2.2 new和delete自定义类型

📖C语言的玩法
先来回顾一下，C语言中针对自定义类型是怎么玩的，以动态申请一个链表节点为例：

//节点类型
struct List_Node
{
	int _val;
	struct List_Node* _next;
};
//申请节点的函数
List_Node* BuyListNode(int x)
{
	List_Node* tmp = (List_Node*)malloc(sizeof(List_Node));
	if (nullptr == tmp)
	{
		perror("malloc");
		exit(-1);
	}

	tmp->_val = x;
	tmp->_next = nullptr;
}
int main()
{
	//动态申请三个节点
	List_Node* p1 = BuyListNode(1);
	List_Node* p2 = BuyListNode(2);
	List_Node* p3 = BuyListNode(3);
	return 0;
}

如上面的代码所示，在C语言中，要想为自定义类型动态申请一块空间，我们单独封装了一个函数BuyListNode，这个函数完成了空间申请、合理性检查、初始化等工作，然后通过调用这个函数实现自定义类型的动态内存申请。
📖C++的玩法

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	//通过new动态申请一块空间，存储A类型变量
	A* p2 = new A(1);
	delete p2;
	//通过new动态申请3个连续空间，存储3个A类型的数据
	A* p6 = new A[3];
	delete[] p6;
	return 0;
}

通过打印结果可以看出，new/delete对于自定义类型出了开空间，还会调用构造函数和析构函数。

小Tips：上面代码中A* p2 = new A(1);，我们进行了人为的初始化，即用圆括号传了一个1，由于new会去调用构造函数，所以这个1最终会被A类构造函数的形参接受，用于初始化对象中的_a成员变量；而A* p6 = new A[3];申请的3个连续空间（数组），我们并没有进行人为的初始化，这在当前环境下也是可以的，因为构造函数的形参有缺省值，属于默认构造函数，new去调用构造函数的时候，可以不需要传实参直接使用缺省值，但是如果A类没有默认构造函数，那我们在使用new动态申请空间的时候，一定要进行人为的传值初始化。

如果A类没有默认构造函数，我们在new的时候就需要人为的传参进行初始化，像下面这样。

//通过new动态申请一块空间，存储A类型变量
A* p2 = new A(1);
//通过new动态申请10个连续空间，存储10个A类型的数据
A* p6 = new A[3]{ 1, 2, 3 };//通过隐式类型转换去初始化
A* p6 = new A[3]{ A(1), A(2), A(3) };//通过匿名对象去初始化
//A* p6 = new A[3]{ A(1), A(2)};//申请了三块空间，只初始化了两个，这是不被允许的

小Tips：对于动态申请的自定义类型数组，如果该自定义类型没有默认构造，则需要进行人为的初始化，并且申请了几块空间就要初始化几个，不像动态申请的内置类型数组，可以只初始化前面一部分，后面默认是0。此外，如果该类的构造函数有多个形参（超过一个），就不支持隐式类型转换去初始化了，可以继续使用匿名对象去初始化。

📖一些建议
这里建议大家malooc、free、new、delete、new[]、delete[]不要混用，严格按照下面的对应关系去使用：

• malloc——free
• new——delete
• new[]——delete[]
  对于内置类型，混用了可能没什么，但是对于自定义类型可就不一定了。
  

三，operator new与operator delete函数

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

小Tips：operator new和operator delete并不是简单的运算符重载哦。

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和operator delete的实现，从中我们可以发现，operator new实际上也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete最终是通过free来释放空间的。

小Tips：operator new、operator delete和malloc、free在功能上相似，都是到堆上申请空间，然后释放空间，它们的区别在于，前者失败了会抛异常，而后者失败了是返回错误码，通过返回值来表示这一块有问题。

四，new和delete的实现原理

4.1内置类型

如果申请的是内置类型的空间，new和malloc，delete和free出了用法上面，其他方面没什么区别，new在申请空间失败时会抛异常，malloc在申请空间失败时会返回NULL。

4.2自定义类型

📖new的原理

• 调用operator new函数申请空间。
• 在申请的空间上执行构造函数，完成对象的构造。

📖delete的原理

• 在空间上执行析构函数，完成对象中资源的清理工作。
• 调用operator delete函数释放对象的空间。

📖new T[N]的原理

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

📖delete[ ]的原理

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

📖new和delete的优势

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	// 其他方法...
	~Stack()//析构函数
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};
void Test()
{
	Stack* ps = (Stack*)malloc(sizeof(Stack));
} 

以栈类为例，动态申请一块栈空间，在内存中的存储结构如下图所示：

梳理一下，首先无论是malloc还是new都会在堆区申请一块空间来存储栈对象，如上图绿色区域所示，其中malloc会直接申请，而new则是通过调用operator new进行申请。申请成功后会返回这块空间的地址，ps存的就是这个地址。其次，Stack对象中的成员变量_array还需要再动态申请一块空间，如上图粉色区域所示，申请成功后会返回这块空间的地址，_array存的就是这个地址。

粉色区域是通过构造函数申请得到的，通过析构函数进行释放的。因为malloc只负责开空间，不会去调用构造函数，因此动态申请到的空间就无法走构造函数进行初始化，可以写一个成员函数Init来完成初始化工作，其次free(ps)只会把绿色那块空间释放了，它不会去调用析构函数释放粉色空间，因此执行完free(ps)后，就会造成内存泄漏（粉色空间没释放，并且之后都找不到这块地址，不能再释放），当然可以自己在类里面写一个Destory函数，在free(ps)前先调用Destory函数释放粉色空间。总之，如果使用malloc和free坑就特别多。

相比之下，这里使用new和delete来申请和释放空间，就会方便很多，new在申请完空间后，会自动调用构造函数，完成初始化工作，delete在释放空间前也会主动调用析构函数，先释放对象中的资源。

五，定位new表达式（placement-new）

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

📖使用格式

• new(place_address)type
• new(place_address)type(initializer-list)
  其中place_address必须是一个指针，initializer-list是类型的初始化列表
  📖使用场景
  定位new表达式在实际中一般是配合内存池使用。因为内存池分配的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定位表达式进行显式调构造函数进行初始化。

int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	//显式调用构造函数
	new(p1)A(10);//定位new表达式
	//显式调用析构函数 
	p1->~A();
	free(p1);
	p1 = nullptr;
	return 0;
}

六，malloc/free和new/delete的区别总结

📖共同点
都是从堆上申请空间，并且需要用户手动释放。

📖不同点

七，内存泄漏

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

📖内存泄漏的危害
长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务器等等，出现内存泄漏会导致响应越来越慢，最终卡死。

📖内存泄漏的分类
C/C++程序中我们一般比较关心下面两种内存泄漏：

• 堆内存泄漏（Heap leak）

堆内存指的是程序执行中依据需要通过malloc、calloc、realloc、new等从堆中分配的内存，用完后必须通过调用相应的free或者delete释放。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

• 系统资源泄漏

指程序使用系统份配的资源，比如套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
📖如何检测内存泄漏
在vs下，可以使用Windows操作系统提供的_CrtDumpMemoryLeaks()函数进行简单的检测，该函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息。

int main()
{
	int* p = new int[10];
	// 将该函数放在main函数之后，每次程序退出的时候就会检测是否存在内存泄漏
	_CrtDumpMemoryLeaks();
	return 0;
}

因此大家在写代码时一定要小心，尤其是动态内存操作时，一定要记得释放。但是有些情况下总是会防不胜防，简单的可以采用上述方法快速定位。如果工程比较大，内存泄漏位置比较多，不太好查时一般都是借助第三方内存泄漏检测工具处理的。

• 在Linux下内存泄漏检测：Linux
• 在Windows下使用第三方工具：Window
• 其他工具：内存泄露工具比较

📖如何避免内存泄漏

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

总结：内存泄漏非常常见，解决方案主要分为以下两种：

• 事前预防性型，如智能指针等。
• 事后查错型，如泄漏检测工具。

💘不知不觉，【C++初阶】一篇手撕内存管理 学习告一段落。通读全文的你肯定收获满满，让我们继续为C++学习共同奋进!!!