【C++之动态内存管理】深剖new和delete的本质

前言

平时我们在函数中创建的变量属于局部变量，其所需要的空间是在栈上开辟的，但是由于栈的大小是有限的，并且比较小，所以很容易就会被用完。因此，我们不能一直在栈上开辟空间，需要学会到其他地方申请空间，比如：堆，堆的大小相比于栈就会比较大了，并且相比于栈上的变量，堆上的变量的生命周期更长。另外，在C语言中我们也学会了使用malloc,calloc,realloc等函数来向堆申请空间，那么C++为什么会再重新使用其他方法呢？？这也是我们这篇文章需要回答的问题。

一、C/C++内存分布

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";// 局部变量
	// C 语言中的动态内存管理方法
	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(ptr2);
	free(ptr3);
}

• globalVar在哪里？
  globalVar是全局变量，所以存在于静态区，系统角度就是存在于数据段。

• staticGlobalVar在哪里？
  staticGlobalVar是静态全局变量，所以存在于静态区，系统角度就是存在于数据段。

• staticVar在哪里？
  staticVar在函数栈帧中，所以是静态局部变量，存在于栈。

• localVar在哪里？
  localVar在函数栈帧中，所以是局部变量，存在于栈。

• num1 在哪里？
  num1 是函数中的一个数组，所以属于局部变量，存在于栈上

• char2在哪里？
  char2是函数中的一个数组，所以属于局部变量，存在于栈上

• *char2在哪里？
  *char2是数组中的内容，也是函数栈帧中的内容，所以存在于栈上

• pChar3在哪里？
  pChar3是一个指向常量字符串的指针，但是这个指针变量是在函数栈帧中定义的，所以也是存在于栈上

• *pChar3在哪里？
  *pChar3是pChar3指向的一个常量字符串，存在于常量区，系统角度叫代码段

• ptr1在哪里？
  ptr1是一个指向由malloc向堆申请的空间，但是这个指针是在函数中定义的，所以这个指针存在于栈上

• *ptr1在哪里？
  *ptr1是由malloc向堆申请的空间，所以这个空间是存在于堆的

• sizeof(num1)
  
  num1是一个整型数组，其中有10个整型空间，所以sizeof(num1) 为4*10 = 40byte

• sizeof(char2)
  
  char2是一个字符数组，其中有4个字符+1个’\0’，所以一共5个字符，故sizeof(char2)为5byte

• strlen(char2)
  
  char2是一个字符数组，strlen()是求字符串的长度，因此只关心有效字符串的内容，显然char2中的有效字符串的长度为4，所以strlen(char2) 为4byte

• sizeof(pChar3)
  
  pChar3是一个指向常量字符串的指针，既然是指针，那么其大小就是4byte或者8byte，故sizeof(pChar3) 为4byte或者8byte

• strlen(pChar3)
  
  pChar3是一个指向常量字符串的指针，strlen()是求字符串的长度，因此只关心有效字符串的内容，显然pChar3指向的字符串的有效长度为4byte，故strlen(pChar3)为4byte

• sizeof(ptr1)
  
  ptr1是一个指向由malloc向堆申请的空间，既然是指针，那么其大小就是4byte或者8byte，故sizeof(ptr1) 为4byte或者8byte

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

我们学习过C语言，所以我们知道C语言中动态内存管理方式是使用malloc函数，calloc函数，realloc函数向堆申请空间。

• malloc函数：向堆申请size字节大小的空间，不初始化，当申请成功时，返回申请空间的地址，申请失败时，返回空指针
  
• calloc函数：num表示元素个数，size表示每一个元素的大小，所以总大小为num*size字节，同时将申请的空间初始化为0，当申请成功时，返回申请空间的地址，申请失败时，返回空指针
  
• realloc函数：一般是在扩容的时候进行使用，第一个参数表示原来空间的地址，当第一个参数为空时，其功能相当于malloc函数，当原来空间后存在足够空间，就会进行原地扩容，当原来空间后面的空间不满足新大小时，则进行异地扩容，当申请成功时，返回申请空间的地址，申请失败时，返回空指针
  

三、C++内存管理方式

1. 针对内置类型（不初始化）

int main()
{
	// C语言
	int* p1 = (int*)malloc(sizeof(int));
	if (p1 == nullptr)
	{
		cout << "malloc fail" << endl;
		return -1;
	}


	// C++ 
	int* p2 = new int;
	free(p1);
	delete p2;

	return 0;
}

• 调试
  
  通过上面的对比，显然：malloc/free和new/delete除了在用法上的不同，其余均相同，就是对于内置类型都不进行初始化。

2. 针对内置类型（初始化）

• 代码

int main()
{
	// C语言
	int* p1 = (int*)malloc(sizeof(int));
	if (p1 == nullptr)
	{
		cout << "malloc fail" << endl;
		return -1;
	}
	*p1 = 1;

	// C++ 
	int* p2 = new int(1);
	
	free(p1);

	delete p2;

	return 0;
}

• 调试
  
  通过上面的代码我们可以看出，使用C语言动态内存管理的方式去申请空间并对其进行初始化和使用C++方式达到的效果是一样的，但是显然C语言的方式会更加麻烦

3. 针对自定义类型：以申请链表新节点作为例子

• 代码

struct ListNode
{
	// 构造函数
	ListNode(int data)
		:_data(data)
		,_next(nullptr)
	{}
	// 成员变量
	int _data;
	ListNode* _next;
};

// 使用C语言方式进行申请结点
ListNode* BuyNewNode(int data)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == nullptr)
	{
		printf("malloc fail\n");
		return nullptr;
	}
	// 初始化
	newnode->_data = data;
	newnode->_next = nullptr;
	return newnode;
}

int main()
{
	// 使用C语言申请新节点
	ListNode* node1 = BuyNewNode(1);

	// 使用C++申请新节点
	ListNode* node2 = new ListNode(1);

	// 释放
	free(node1);
	delete node2;
	return 0;
}

• 调试
  

显然两种方式达到的效果是一样的，但是使用C语言的方式显然会比较麻烦，需要实现一个申请新节点的函数，而且在使用malloc函数的过程中还需要判断是否申请成功，同时，malloc函数只负责开空间，不对空间中的内容进行初始化，相比之下，使用C++中的new就比较简单，并且通过调试，我们可以发现，使用new的时候除了负责开空间之外，还会调用这个自定义类型的构造函数完成对象的初始化工作，而且使用new还不需要检查是否开空间成功。

4. new的其他玩法
   上面是使用new申请一个对象的空间并进行初始化，我们也可以使用new来申请多个对象，下面我们分别使用C++和C语言的方式来申请10个整型的空间

int main()
{
	// C++
	int* p1 = new int[10];

	// C语言
	int* p2 = (int*)malloc(sizeof(int) * 10);
	if (p2 == nullptr)
	{
		printf("malloc fail\n");
		return -1;
	}

	delete[] p1;
	free(p2);

	return 0;
}

• 调试
  

5. 初始化多个对象

int main()
{
	// C++
	int* p1 = new int[10]{1,2,3,4,5,6,7,8,9,10};

	// C语言
	int* p2 = (int*)malloc(sizeof(int) * 10);
	if (p2 == nullptr)
	{
		printf("malloc fail\n");
		return -1;
	}

	for (int i = 0; i < 10; i++)
	{
		p2[i] = i+1;
	}

	delete[] p1;
	free(p2);

	return 0;
}

• 调试
  

四、深度对比C语言和C++动态内存管理方式处理自定义类型的区别

• 代码

class Test
{
public:
	Test()
		: _data(0)
	{
		cout << "Test():" << this << endl;
	}
	~Test()
	{
		cout << "~Test():" << this << endl;
	}
private:
	int _data;
};
void Test2()
{
	// 申请单个Test类型的空间
	Test* p1 = (Test*)malloc(sizeof(Test));
	free(p1);
	// 申请10个Test类型的空间
	Test* p2 = (Test*)malloc(sizeof(Test) * 10);
	free(p2);
}

void Test3()
{
	// 申请单个Test类型的对象
	Test* p1 = new Test;
	delete p1;
	// 申请10个Test类型的对象
	Test* p2 = new Test[10];
	delete[] p2;
}

int main()
{
	Test2();
	Test3();
	return 0;
}

• 调试
  调用Test2()
  
  调用Test3()
  
  

运行结果：

从上述的代码的调试和运行结果来看：

• 申请资源：使用C语言中的malloc函数只会空间，不会进行初始化，使用C++中的new不但会开空间，而且还会调用自定义类型的构造函数完成初始化，使用new+类型就只会开一个对象的空间，调用一次构造函数完成初始化，使用new类型[N],就会开N个对象的空间，同时调用N次这个自定义类型的构造函数完成这N个对象的初始化。
• 释放资源：使用C语言的free函数只会单独释放空间，使用C++中的delete除了释放自定义类型的空间，还会调用这个自定义类型的析构函数完成这个对象中资源的释放，最后再delete这个对象，如果使用new+类型的，那么就匹配使用delete+指针，这样就只会调用一次析构函数释放资源，如果使用new+类型+[N]创建了N个对象，那么就需要匹配使用delete+[]+指针去调用N次这个自定义类型的析构函数完成这N个对象中资源的释放。

总结：申请资源方面：C语言的方法只会开空间不会初始化，C++除了开空间，还会调用自定义类型中的构造函数完成对象的初始化。释放资源方面：C语言只会直接释放整个对象的空间，不会释放对象中的资源，容易造成内存泄露，C++在释放对象前会调用自定义类型的析构函数完成对象中资源的释放，最后再释放对象空间，不会造成内存泄露。

五、operator new与operator delete函数

1. 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)

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功，就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的

需要注意的是：operator new和operator delete不是运算符重载函数，是系统提供的一个全局函数，需要和运算符重载区分开。
我们在上面学习的new和delete本质是运算符，其底层就是通过封装operator new和operator delete来实现的，处理自定义类型的时候，new的底层是封装operator
new+调用自定义类型的构造函数来实现，delete的底层是通过调用operator
delete+调用自定义类型的析构函数来实现的。其中的operator new是封装malloc函数+抛异常实现的，operator delete是通过封装free函数实现的。

六、类专属的operator new和operator delete

上面学习的系统提供的全局函数，我们还可以在类中实现new和delete的运算符重载函数，那么就会形成对应的类专属operator new和operator delete，也就是假如我们在某一个类中实现了专属的operator new和operator delete的运算符重载函数，那么当我们在创建对象的时候使用new的时候就会去调用这个类专属的operator new ，当我们在delete这个对象的时候，那么此时就会去调用这个类的专属operator delete，下面我们举一个链表结点的例子来帮助理解：

struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _data;
	void* operator new(size_t n)
	{
		void* p = nullptr;
		// p = allocator<ListNode>().allocate(1);
		cout << "memory pool allocate" << endl;
		return p;
	}
	void operator delete(void* p)
	{
		// allocator<ListNode>().deallocate((ListNode*)p, 1);
		cout << "memory pool deallocate" << endl;
	}
};
class List
{
public:
	List()
	{
		_head = new ListNode;
		_head->_next = _head;
		_head->_prev = _head;
	}
	~List()
	{
		ListNode* cur = _head->_next;
		while (cur != _head)
		{
			ListNode* next = cur->_next;
			delete cur;
			cur = next;
		}
		delete _head;
		_head = nullptr;
	}
private:
	ListNode* _head;
};
int main()
{
	List l;
	return 0;
}

这个例子主要是要关注结点类型的创建，所以就要关注结点类型中的构造函数和析构函数，当我们new一个结点类型的对象的时候，因为我们在结点类型中实现了new的重载函数operator new，所以此时new+结点类型这行代码就会跳进我们实现的operator new函数执行对应的逻辑。当我们在delete一个结点的时候，我们同样在结点类型中实现了delete的重载，也就是operator delete函数，所以在执行delete+结点指针的时候，就会跳进我们实现的operator delete函数执行对应的逻辑。