C++：内存管理

C++内存管理方式(new&delete)

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因
此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
---- int* ptr1 = new int(3) 。申请一个int内存的 空间，并初始化为3.
---- int* ptr2 = new int[3]。 申请一个大小为3的int类型的数组。
---- delete ptr1 。指向单个对象的指针直接delete 。
---- delete[ ] ptr2 。指向数组多个对象的指针用 delete [ ] 。

C语言中malloc可以申请空间，那我们为什么还要使用new?
---- 针对内置类型(int、char...)，malloc和new两种申请空间的方式没区别。
---- 针对自定义类型(类创建对象)，malloc和free仅仅申请空间和销毁空间；而new在申请空间时会调用类的构造函数进行初始化，用delete销毁时也会调用类的析构函数来销毁。

我们分别以C/C++创建链表结点为例，体现C++使用new&delete的规范性。

（1）C语言定义链表结点结构体、创建初始化结点、销毁结点。

struct ListNode_C//定义结点结构体
{
	int _val;
	struct ListNode_C* _next;
	struct ListNode_C* _prev;
};
typedef struct ListNode_C ListNode_C;//重命名
ListNode_C* BuyListNode(int val)//创建初始化
{
	ListNode_C* node_c = (ListNode_C*)malloc(sizeof(ListNode_C));
	node_c->_val;
	node_c->_next = NULL;
	node_c->_prev = NULL;
	return node_c;
}
void DestoryListNode(ListNode_C* node);//销毁

（2）C++定义链表类，创建结点(声明成员变量)、初始化结点(调用构造函数)、销毁(调用析构函数) ；struct在C++中也可以被看作class，但是class的默认访问权限是private，struct是public。

struct ListNode_CPP
{//在CPP中，struct可以被认为是类，只是默认访问权限有所区别
	int _val;
	struct ListNode_CPP* _next;//兼容C struct的用法
	struct ListNode_CPP* _prev;
	//C++中默认的构造函数也会将内置的成员变量初始化成随机值
	ListNode_CPP(int val=1)
		:_val(val)
		, _next(NULL)
		, _prev(NULL)
	{}
	~ListNode_CPP();
};

（3）创建节点时的区别：

int main()
{
	ListNode_C* node1 = BuyListNode(1);
	//new会自动调用构造函数进行初始化，更加规范
	ListNode_CPP* node4 = new ListNode_CPP;
    ListNode_CPP* node4 = new ListNode_CPP(1);
}

提问：malloc和new有什么区别？
----概念性质：malloc是一个函数，new是一个操作符
----使用效果：malloc只申请空间，new会调用析构函数
----使用方法：malloc的参数是申请空间大小的字节数，返回类型是void*；new跟申请对象的类型，返回值是类型的指针。

operator new与operator delete函数

operator new()该函数在内存空间正常被申请时和malloc()的实现一样。但当申请空间过大导致申请内存失败时，malloc()函数会返回0，但这不符合面向对象的特性，就创建了operator new()函数，它调用malloc函数申请空间，当malloc申请失败返回0时它就抛出异常。函数代码如下：

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

malloc()和operator new()的用法：

int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = (A*)operator new(sizeof(A));
	//malloc()
	size_t size = 2;
	void* p4 = malloc(size*1024*1024*1024);
	cout << p4 << endl;//失败返回0
    //operator new()
	try
	{
		void* p5 = operator new(size * 1024 * 1024 * 1024);
		cout << p5 << endl;//失败抛异常(面向对象处理方式)
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
}

----辨析：malloc \ operator new \ new
malloc申请空间，失败则返回0；operator new调用malloc申请空间，失败抛异常；
new调用operator new申请空间，失败抛异常，同时调用自定义类型的构造函数。
----辨析：free \ operator delete \ delete
free释放空间，释放空间失败直接终止进程；operator delete直接调用free，没有区别；delete也同样释放空间，但对于自定义类型调用它的析构函数。

用new申请空间，用operator new模拟一个：

A* p1 = new A;
delete p1;

A* p2 = (A*)operator new(sizeof(A));
//对已经存在的一块空间调用构造函数初始化，定位new/replacement new
new(p2)A;//new(空间的指针)类型(参数)
p2->~A();//调用析构函数
operator delete(p2);

内存泄露 

申请出来的空间不再使用，但是没有释放就会造成内存泄露；Java的垃圾回收器可以自动清理回收内存，而C++需要专门回收内存。
内存泄露危害：当一个程序内存泄露，随着程序结束进程结束内存会被释放不会造成什么危害；但如果一个程序要长期运行，或者本身的内存就很小，一直内存泄露会导致卡死。
如何让进行防治？检测内存泄漏工具、C++智能指针...
申请一个2GB大小的空间：

int main()
{
	size_t n = 2;
	try
	{
		void* p = new char[n * 1024 * 1024 * 1024];
		cout << "new:" << p << endl;
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}