C/C++动态内存管理

#include<iostream>
using namespace std;

//1.C语言中的动态内存管理
//malloc/calloc/realloc/free

#if 0
#include<stdlib.h>
int main()
{
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);

	//malloc/calloc/realloc的区别是什么？
	int* p2 = (int*)calloc(4, sizeof(int)); //申请了4个整形大小的空间，并将所有位
											//初始化位0,成功返回指向该内存的地址，失败返回空指针
		
	int* p3 = (int*)realloc(p2, sizeof(int*) * 10);//在原先的空间基础上申请更大的空间，
		//如果原空间后有足够的则申请成功返回的是p2，如果不够则在新的区域申请，成功则返回新的地址空间
		//是被则返回空。

	//free(p2);  //不需要free(p2)， 要么p3 = p2,要么p2已经不存在

	free(p3);  

	return 0;
}
#endif

//2.C++动态内存管理

//1. 它们都是动态管理内存的入口。
//2. malloc / free是C / C++标准库的函数，new / delete是C++操作符。 
//3. malloc / free只是动态分配内存空间 / 释放空间。
//而new / delete除了分配空间还会调用构造函数和析构函数进行初始化与清理（清理 成员）。
//4. malloc / free需要手动计算类型大小且返回值会void * ，new / delete可自己计算类型的大小，
//返回对应类型的指针。

#if 0
int main()
{
	//动态申请一个int类型空间
	int* ptr4 = new int;

	//动态申请一个int类型空间并初始化位10
	int* ptr5 = new int(10);
	//cout << *ptr4 << "  " << *ptr5 << endl;

	//动态申请3个int类型的空间
	int* ptr6 = new int[3];
	cout << ptr6 << endl;

	delete ptr4;
	delete ptr5;
	delete[] ptr6;

	return 0;
}
//申请和释放单个元素的空间，使用new和delete操作符,
//申请和释放连续的空间，使用new[]和 delete[]
#endif

//3.new和delete操作自定义类型
#if 0
class Test
{
public:
	Test()
		:_data(0)
	{
		cout << "Test():" << this << endl;
	}

	~Test()
	{
		cout << "~Test():" << this << endl;
	}


private:
	int _data;
};

//mallco/free
void Test1()
{
	//申请单个Test类型空间
	Test* p1 = (Test*)malloc(sizeof(Test));
	free(p1);

	//申请10个Test类型的空间
	Test* p2 = (Test*)malloc(sizeof(Test) * 10);
	free(p2);
}

//new 和delete
//在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，
//而malloc与free不会
void Test2()
{
	//申请单个Test 的类型空间
	Test* p1 = new Test;
	delete p1;

	//申请10个Test类型空间
	Test* p2 = new Test[10];
	delete[] p2;
}

int main()
{
	//Test1();
	Test2();

	return 0;
}
#endif

//4.operator new 和 operator delete函数

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

//通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，
//如果malloc申请空间 成功就直接返回，否则执行用户提供的空间不足应对措施，
//如果用户提供该措施就继续申请，否则就抛异 常。
//operator delete 最终是通过free来释放空间的

#if 0
struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	int _data;

	void* operator new(size_t)
	{
		void* p = nullptr;
		p = allocator<ListNode>().allocate(1); //allocator默认分配器
		cout << "memor pool allocator" << 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;
}
#endif

//5.new 和delete的实现原理

//如果申请的是内置类型的空间，new和malloc，delete和free基本类似，
//不同的地方是：new / delete申请和 释放的是单个元素的空间，
//new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常， 
//malloc会返回NULL

//自定义类型

//new的原理 
//1. 调用operator new函数申请空间 
//2. 在申请的空间上执行构造函数，完成对象的构造 
//
//delete的原理 
//1. 在空间上执行析构函数，完成对象中资源的清理工作
//2. 调用operator 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来释放空间

#if 0
//6.定位new表达式(placement-new)

class Test
{
public:
	//Test()
	Test(int data)
		//:_data(0)
		:_data(data)
	{
		cout << "Test():" << this << endl;
	}

	~Test()
	{
		cout << "~Test():" << this << endl;
	}

private:
	int _data;
};

int main()
{
	//pt 现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，
	//因为构造函数没有执行
	Test* pt = (Test*)malloc(sizeof(Test));

	//new(pt) Test; //如果Test类的构造函数有参数时，此处需要传参
	new(pt) Test(10);
	free (pt);

	return 0;
}
#endif

//malloc / free和new / delete的区别

//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在释放空间前会调用析构函数完成空间中资源的清理 
//7. new / delete比malloc和free的效率稍微低点，因为new / delete的底层封装了malloc / free


//7.设计一个类，该类只能在堆上创建对象
//方法一：构造函数私有化 
//1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。 
//2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

#if 0
class HeapOnly
{
public:
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}

private:
	HeapOnly(){}
	//C++98
	//1.只声明不实现。因为实现可能会很麻烦，而你本身不需要
	//2.声明成私有的
	HeapOnly(const HeapOnly& h);

	//C++11
	HeapOnly(const HeapOnly& h) = delete;
};

//请设计一个类，该类只能在栈上创建对象


class StackOnly
{
public:
	static StackOnly CreateObject()
	{
		return StackOnly();
	}

private:
	StackOnly() {};
};


//or

//只能在栈上创建对象，即不能在堆上创建，因此只要将new的功能屏蔽掉即可，
//即屏蔽掉operator new和定 位new表达式，
//注意：屏蔽了operator new，实际也将定位new屏蔽掉。

class StackOnly
{
public:
	StackOnly();

private:
	void* operator new(size_t size);
	void operator delete(void* p);
};
#endif

//8.内存泄漏

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

#if 0
int main()
{
	//1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;

	//2.异常安全问题
	int* p3 = new int[10];

	//Func(); //这里的Func函数抛出异常导致delete[]p3未执行，p3没被释放

	return 0;
}
#endif

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

#if 0
//一次在堆上申请4G的内存

//将程序编译成x64的进程
int main()
{
	void* p = new char[0xffffffff];
	cout << "new:" << p << endl;

	return 0;
}
#endif