new与delete原理剖析

一、operator new与operator delete函数

        C++除了提供【new】和【delete】关键字来进行动态内存管理，还提供了【operator new】与【operator delete】函数来进行动态内存管理

        【new】和【delete】是用户进行动态内存申请和释放的操作符，【operator new】和【operator delete】是系统提供的全局函数

        【new】在底层调用【operator new】全局函数来申请空间，【delete】在底层通过【operator delete】全局函数来释放空间

        1、 operator new

【operator new】：

        该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常 

        C++系统库中的【operator new】实现：

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 new】的返回值是【void *】类型的，【size】为申请的空间大小，而该函数的核心就是使用【malloc】申请空间，如果【malloc】申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常

         2、operator delete

【operator delete】： 

        该函数最终是通过free来释放空间的

        C++系统库中的【operator delete】实现： 

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

#define free(p) _free_dbg(p, _NORMAL_BLOCK)

        3、小结 

        【operator new】和【operator delete】有很多代码都看不懂，但是没有关系，我们只需要得到一个结论：

• 【operator new】是【malloc】的封装，【operator delete】是【free】的封装 
• 【operator new】与【operator delete】用法和【malloc】与【free】的用法是一样的

        示例： 

int main()
{
	int* num = (int*)operator new(sizeof(int));
	*num = 100;
	cout << *num << endl;
	operator delete(num);
}

         结果：

二、new与delete原理 

        1、内置类型

new的原理：

1. 调用【operator new】函数申请空间

delete的原理：

1. 调用【operator delete】函数释放对象的空间

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

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

        2、自定义类型 

new的原理：

1. 调用【operator new】函数申请空间
2. 在申请的空间上执行构造函数，完成对象的构造

delete的原理：

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

        示例：

class Test
{
public:
	Test(int n = 100)
		:num(n)
	{
		cout << "构造函数" << endl;
	}
	~Test()
	{
		cout << "析构函数" << endl;
	}
private:
	int num;
};

int main()
{
	//原理:operator new + 构造函数
	Test* t = new Test;

	//原理:operator delete + 析构函数
	delete t;
	return 0;
}

        【new】底层运行逻辑：

        【delete】底层运行逻辑： 

        对于【new】和【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】来释放空间

        示例：

int main()
{
	//原理:operator new [ ] + 构造函数
	Test* t = new Test[10];

	//原理:operator delete [ ] + 析构函数
	delete[] t;
	return 0;
}

        【new】底层运行逻辑：

        值得注意的是这里调用的【operator new [ ] 】 函数，但是【operator new [ ] 】 函数其实就是【operator new】

        【operator new [ ] 】函数的底层实现：

void* __CRTDECL operator new[](size_t const size)
{
    return operator new(size);
}

        【delete】底层运行逻辑：  

        【delete】这边也是一样的，虽然调用的是【operator delete [ ] 】 函数，但是【operator delete [ ] 】 函数其实就是【operator delete】

        【operator delete [ ] 】函数的底层实现： 

_CRT_SECURITYCRITICAL_ATTRIBUTE
void __CRTDECL operator delete[](void* const block, size_t const) noexcept
{
    operator delete[](block);
}

【注意】

        如果使用【new】时带方括号，则使用【delete】时也因该带方括号。如果使用【new】时不带方括号，则使用【delete】时也因该不带方括号。它们之间要匹配使用

        【new】与【delete】的格式不匹配导致后果是不确定的，因此我们不能依赖于某种特定的行为