C++内存管理

一、内存分布

C++程序在执行时，将内存大方向划分为4个区域

• 代码区：存放函数体的二进制代码，由操作系统进行管理的
• 全局区：存放全局变量和静态变量以及常量
• 栈区：由编译器自动分配释放, 存放非静态局部变量/函数参数/返回值等等
• 堆区：用于程序运行时动态内存分配。由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收

二、动态内存管理

2.1 使用

int main()
{
	//申请空间
	int* p1 = new int;
	int* p2 = new int[10];

	//销毁空间
	delete p1;
	delete[] p2;

	// 申请空间+初始化
	int* p3 = new int(0);
	int* p4 = new int[10]{ 0 };
	int* p5 = new int[10]{1,2,3,4,5};

	//销毁空间
	delete p3;
	delete[] p4;
	delete[] p5;

	return 0;
}

2.2 特性

看下面一段示例代码

#include<iostream>
#include<stdio.h>

using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	cout << "自定义类型演示" << endl;
	A* p1 = (A*)malloc(sizeof(A));
	cout << endl;
	A* p2 = new A(1);
	free(p1);
	delete p2;
	cout << endl;
	cout << "内置类型演示" << endl;
	cout << endl;
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;
	free(p3);
	delete p4;
	cout << "自定义类型数组演示" << endl;
	A* p5 = (A*)malloc(sizeof(A) * 10);
	cout << endl;
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
	return 0;
}

 

可以观察到：

1. 内置类型：malloc/free与new/delete没有区别
2. 自定义类型：new会调用构造函数，delete会调用析构函数，而malloc与free不会。

三、new/delete的实现原理

3.1 底层源代码

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

可以看到new函数的底层实际上通过malloc开辟空间的，只是通过封装赋予了其抛异常的特性。

delete的函数的实现同理：实际上通过free释放空间的，只是通过封装赋予了其抛异常的特性。

3.2 原理分析

内置类型

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

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

自定义类型

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