目录

一.C语言中的动态内存管理方式

二.C++中的内存管理方式 

1.new/delete操作内置类型 

2.new和delete操作自定义类型 

3.浅识抛异常 （内存申请失败）

4.new和delete操作自定义类型 

三.new和delete的实现原理 

1.内置类型 

2.自定义类型 

---

一.C语言中的动态内存管理方式

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

	// 1.malloc/calloc/realloc的区别是什么？
	int* p2 = (int*)calloc(4, sizeof(int));
	int* p3 = (int*)realloc(p2, sizeof(int) * 10);

	// 这里需要free(p2)吗？
	free(p3);
}

答：不需要，realloc分为原地扩容和异地扩容，原地扩容的话返回一个指针，所以p3和p2是相等的；异地扩容的话会将原来的空间自动free掉。

二.C++中的内存管理方式 

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因 此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。 

1.new/delete操作内置类型 

void Test()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;

	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);

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

	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

 

 注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用 new[]和delete[]，注意：匹配起来使用。

2.new和delete操作自定义类型 

•  C语言写法建立结点

struct ListNode* CreateListNode(int val)
{
	struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	newnode->_next = NULL;
	newnode->_val = val;
	return newnode;
}

• C++建立结点 

struct ListNode
{
	ListNode* _next;
	int _val;

	ListNode(int val)
		:_next(nullptr)
		,_val(val)
	{}
};
int main()
{
	
	//自定义类型，开空间+构造函数;new失败了以后抛异常，不需要手动检查
	ListNode* node1 = new ListNode(1);
	ListNode* node2 = new ListNode(2);
	ListNode* node3 = new ListNode(3);
	

	return 0;
}

• C++手撕一个链表 

// 创建的不带哨兵位
ListNode* CreateList(int n)
{
	ListNode head(-1);  // 哨兵位

	ListNode* tail = &head;
	int val;
	printf("请依次输入%d个节点的值：>", n);
	for (size_t i = 0; i < n; i++)
	{
		cin >> val;
		tail->_next = new ListNode(val);
		tail = tail->_next;
	}

	return head._next;
}
int main()
{
	ListNode* list1 = CreateList(5);
	return 0;
}

3.浅识抛异常 （内存申请失败）

void func()
{
	int n = 1;
	while (1)
	{
		int* p = new int[1024 * 1024 * 100];
	
		cout << n << "->" << p << endl;
		++n;
	}
}
int main()
{
	func();
	return 0;
}

• C语言内存申请失败 

对比发现C语言申请失败返回0需要检查,而C++不需要检查，直接抛异常。 

4.new和delete操作自定义类型 

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}

	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

class Stack
{
public:
	Stack()
	{
		_a = (int*)malloc(sizeof(int) * 4);
		_top = 0;
		_capacity = 4;
	}

	~Stack()
	{
		free(_a);
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	//int* p1 = (int*)operator new(10 * 4);

	A* ptr1 = new A;  // operator new + 1次构造
	A* ptr2 = new A[10]; // operator new[] + 10次构造

	//cout << sizeof(A) << endl;
	delete ptr1; // 1次析构 + operator delete
	delete[] ptr2; // 10次析构 + operator delete[]

	Stack* pst = new Stack;
	delete pst;

	int* p1 = new int[10];

	return 0;
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数（先掉析构函数再释放内存），而malloc与 free不会。 

三.new和delete的实现原理 

1.内置类型 

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

2.自定义类型 

 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来释 放空间