C/C++内存管理

C语言中动态内存管理方式：malloc/calloc/realloc/free

void Test()
{
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);

	int* p2 = (int*)calloc(4, sizeof(int));//calloc会初始化
	int* p3 = (int*)realloc(p2, sizeof(int) * 10);
	p2 = nullptr;//如果realloc是异地扩容，p2有可能会是野指针
	free(p3);
}

C++兼容C语言，所以C语言这一套C++也可以用

C++内存管理方式

new/delete操作内置类型

申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]

void test()
{
	//动态申请一个int类型的空间
	int* ptr1 = new int;
	delete ptr1;
	//动态申请一个int类型空间并初始化为10
	int* ptr2 = new int(10);
	delete ptr2;
	//动态申请10个int类型的空间
	int* ptr3 = new int[10];
	delete[] ptr3;
}

new/delete操作自定义类型

class Test
{
public:
	Test()
		:_data(0)
	{
		cout << "Test()" << this << endl;
	}
	~Test()
	{
		cout << "~Test()" << this << endl;
	}
private:
	int _data;
};
int main()
{
	//申请单个Test类型的对象
	Test* p1 = new Test;
	delete p1;
	//申请10个Test类型的对象
	Test* p2 = new Test[10];
	delete[] p2;
	return 0;
}

在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数；而malloc与free不会

operator new 与 operator delete函数

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

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

void* __CRTDEL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	void* p;
	while ((p = malloc(size)) == 0)//调用malloc
	{
		//report no memory
		//如果申请内存失败了，这里会抛出bad_alloc 类型异常
		if (_callnewh(size) == 0)
		{
			static const std::bad_alloc nomen;
			_RAISE(nomen);
		}
	}
	return (p);

}

operator delete
free是宏函数，它调用的也是 _free_dbg

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

void operator delete(void* pUserData)
{
	_CrtMemBlockHeader* pHead;
	RTCCALLBACK(_RTC_Free_hook, pUserData, 0);
	if (pUserData == NULL)
	{
		return NULL;
	}
	_mlock(_HEAP_LOCK);
	__TRY
		pHead = PHtr(pUserData);
		_ASSERT(_BLOCK_TYPE_IS_VALID(phead->nBlockUse));
		_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK)；
	__END_TRY_FINALLY

	return;
}

operator new和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;
};

new和delete实现原理

内置类型

如果申请的是内置类型的空间，new、delete和malloc、free基本类似
不同的是:new/delete申请和释放的是单个元素空间，new[]/delete[]申请和释放的是连续空间；new在申请失败时会抛异常，malloc会返回NULL（面向对象语言处理失败，不喜欢用返回值，更建议抛异常）

自定义类型

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

定位new表达式（placement-new）

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象
使用格式：new（place_address）type或者new（place_address）type（initializer-list）

class A
{
public:
	A()
		:_data(0)
	{
		cout << "Test()" << this << endl;
	}
	~A()
	{
		cout << "~Test()" << this << endl;
	}
private:
	int _data;
};

int main()
{
	//这里p指向的只不过是与A对象大小相同的一段空间，还不算一个对象，因为构造函数没有执行
	A* p = (A*)malloc(sizeof(A));
	//显式调用构造函数
	new(p)A;
	//显示调用析构函数
	p->~A();
	return 0;
}

malloc/free和new/delete的区别

• 共同点：都是从堆上申请，并且需要用户手动释放。不同：

1. malloc/free是函数，new/delete是操作符
2. malloc申请的空间不会初始化，new可以初始化
3. malloc申请空间时，需要手动计算空间大小并传递；new只需在其后跟上空间的类型
4. malloc的返回值为void*，在使用时必须强转；而new不需要，因为new后面跟的是空间的类型
5. malloc申请空间失败时，返回的是NULL，因此使用时，必须判空；new不需要，但是new需要捕获异常
6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数和析构函数；而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

内存泄漏

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄露并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了堆该段内存的控制，因而造成了内存的浪费
危害：
长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务……出现内存泄漏会导致响应越来越慢，最终卡死

void MemoryLeak()
{
	//内存申请，完事了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;
	//异常安全问题
	int* p3 = new int[10];

	Func3();//这里Func3抛异常导致delete[] p3未执行，p3未被释放
	delete p3;
}

内存泄漏分类

堆内存泄漏（Heap Leak）
程序执行中依据需要分配通过malloc/calloc/realloc/new等从堆中分配的一块内存， 用完后必须通过调用相应的free或者delete删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak
系统资源泄漏
程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少、执行不稳定