new和delete

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

new动态开辟空间还可以调用其构造函数对其初始化，可以对于之定义类型进行初始化，
malloc只会动态开辟空间，不会初始化
但是对于内置类型没有区别

delete可以完成资源的清理和空间的销毁，对于自定义类型可以调用其析构函数完成其资源的清理
free只会完成空间的销毁

用法：

class A
{
   

	int _a;
	int _b;
public:
	A()
	{
   
		cout << "A()" << endl;
	}
	~A()
	{
   
		cout << "~A()" << endl;
	}
};

int main()
{
   
	//总结malloc/free和new/delete 对于内置类型没有本质的区别，只有用法上的区别


	//动态申请int和5个int的数组

	//c语言

	int* ptr1 = (int *)malloc(sizeof(int));
	int* ptr2 = (int*)malloc(sizeof(int) * 5);

	//c++
	int* p3 = new int;//动态开辟一个int
	int* p4 = new int[5];//动态申请5个int的空间
	int* p5 = new int(5);//申请1个int空间，**初始化**为5
	int* p6 = new int[5]{
    1,2 };//5个int也可以这样初始化


	//删除
	free(ptr1);
	free(ptr2);
	ptr1 = nullptr;
	ptr2 = nullptr;
	delete p3;
	delete[] p4;
	p3 = nullptr;
	p4 = nullptr;

	A* pa = (A*)malloc(sizeof(A));
	A* pa2 = new A;
	//对于自定义类型，new还可以调用其初始化，还可以开空间
	//malloc只会开空间

	A* pa3 = (A*)malloc(sizeof(A) * 5);
	A* pa4 = new A[5];

	//delete要先调用指针类型的析构函数，再去释放空间给堆上
	delete pa3;
	delete[] pa4;



	return 0;

}

需要注意的是new要和delete配对
new[]要和delete[]配对

new和delete的应用

class Stack
{
   
private:
	int _top;
	int _capacity;
	int* _a;
public:
	Stack(int capacity = 4)
		:_top(0)
		,_capacity(4)
	{
   
		_a = new int[capacity];//对于*a的处理初始化非常方便
	}
	~Stack()
	{
   
		delete[] _a;//清理资源
		_a = nullptr;
	}
};

int main()
{
   
  Stack* s1 = new Stack;//会自动调用构造函数和开空间，
	delete s1;//调用析构函数，清理对象中的资源再释放空间，先把里面的资源给干掉，再释放掉s1指向的这空间给释放掉
return 0;
}

```cpp
struct ListNode
{
   
	ListNode* prev;
	ListNode* next;
	int _val;

	ListNode(int val)//初始化列表
		:prev(nullptr)
		,next(nullptr)
		,_val(val)
	{
   }



};

class List
{
   
public:
	List()//双向带头循环链表,构造函数初始化
	{
   
		_head = new ListNode(-1);
		_head->next = _head;
		_head->prev = _head;
	}
	void pushback(int val)
	{
   
		ListNode* newnode = new ListNode(val);//这样用的话就是用一次就删除一次，因为new调用operator new ，operator new又调用malloc，
		//所以我们就可以存在一个新的operator new，使用内存池
		ListNode* tail = _head->prev;
		tail->next = newnode;
		newnode->prev = tail;
		_head->prev = newnode;
		newnode->next = _head;

	}

private:
	ListNode* _head;
};

int main()
{
   
struct ListNode* n1 = (struct ListNode*)malloc(sizeof(ListNode));
	n1->prev = nullptr;
	n1->next = nullptr;
	n1->_val = 0;

	//cpp
	ListNode* n2 = new ListNode(0);//更加容易
return 0;
}

new和delete的底层

operator new和operator delete

operator new中调用malloc申请内存，但是malloc失败之后返回null，而operator new失败以后，改为抛异常处理错误，这样符合c++面向对象语言处理错误的方式
这个operator new是给new用的一般不是给我们用的

new就是使用operator new（申请空间）+调用构造函数（初始化）

Stack* ps1 = (Stack*)operator new(sizeof(Stack));//只会开空间不会调用构造函数，

同理operator delete就是只会申请空间，不会调用析构函数，也是给delete所使用的

operator delete ps1;//就只会销毁空间，和free差不多

定位new

定位new对已经分配的原始内存空间中调用构造函数初始化一个对象
用法：
new(地址)类型（值）

定位new表达式在实际中一般时配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

class A
{
   
public:
	A(int a)
		:_a(a)
	{
   }
	~A()
	{
   
	}
private:
	int _a;
};

int main()
{
   
	A* p = (A*)malloc(sizeof(A));
	new(p)A(1);//new(地址)类型（值），对一块已经分配好的内存调用初始化构造函数，不开辟空间
	//对于内存池来的就用定位new

	//析构函数
	p->~A();//
	operator delete(p);
	return 0;
}

内存泄漏

1–动态申请的内存，不使用了，又没有主动释放，就存在内存泄漏了
2–内存泄露的危害：
a，出现内存泄露的进程会正常结束，进程结束时这些内存会还给系统，不会又危害
b，出现内存泄露的进程非正常结束，比如僵尸内存，系统用的内存越来越少
c。需要长期运行的程序出现内存泄露，危害很大，系统会越来越满，甚至卡死宕机 —服务器程序，