文章目录

一、C/C++内存分区
二、C语言中动态内存管理方式
三、C++内存管理方式
- 1.new/delete操作内置类型
- 2.C++为什么要搞new和delete
- 3.C++中new和delete操作自定义类型
- 4.非要乱用delete和free会造成什么后果？
四、 operator new与operator delete函数
五、operator new和operator delete的实现原理
- 1.内置类型
- 2.自定义类型
- 3.栈
六、定位new表达式（placement-new）
- 1.定位new的使用
- 2.池化技术
- 3.在内存池的应用
七、malloc/free和new/delete的区别
八、内存泄漏
- 1. 什么是内存泄漏，内存泄漏的危害
- 2.内存泄漏分类

一、C/C++内存分区

我们知道，程序运行时候，会将数一些据存储起来，这些数据可分为：

局部数据
静态数据和全局数据
常量数据
动态申请数据

当我们程序运行后，就会在进程地址空间中为程序分配空间
在这里插入图片描述

我们现在可以来看一些题目
在这里插入图片描述

答案如下
在这里插入图片描述
前五题都是比较容易得到答案，但是后面的几个容易出错

栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口
创建共享内存，做进程间通信。
堆用于程序运行时动态内存分配，堆是可以上增长的。
数据段–存储全局数据和静态数据。
代码段–可执行的代码/只读常量

在这里插入图片描述

二、C语言中动态内存管理方式

这里的内容，在前面的博客中有更加详细的讲解：C语言动态内存管理
我们这里简单的提一下：C语言中动态内存管理有四个函数:malloc、calloc、realloc、free。
malloc用于开辟某一段空间，然后返回这快空间的地址
calloc在开辟空间的基础之上，又可以将这块空间按字节初始化。
realloc是在一块已经开辟空间的基础之上，可以进行扩容。如果后面空间足够，则连续扩容，若不足够，那么就只能另寻一片空间，然后释放掉原来的空间
free则是释放掉某一块空间

三、C++内存管理方式

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

1.new/delete操作内置类型

如下代码所示，是一段比较简单的进行内存管理的代码。p1和p3都是c语言中的内存管理，都比较容易。p2是c++中开辟一个int的空间然后返回这个地址。p4是开辟一个长度为10，类型为int的数组返回起始地址给p4。delete则是释放掉这块空间。对于数组而言开辟空间不难理解，因为对于int a[10]这样一个数组而言，它的类型就是int[10]。所以new不难理解。对于delete我们需要注意了，delete释放空间的时候，后面是写指针的，如果是数组就需要加上[]。

int main()
{
	//c
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);

	//c++
	int* p2 = new int;
	delete p2;

	//c
	int* p3 = (int*)malloc(sizeof(int) * 10);
	free(p3);

	//c++
	int* p4 = new int[10];
	delete[] p4;
}

这时候我们似乎理解了，但是我们发现，其实对于p4，如果我们非要给他delete时候，不带上[]，倒也没报错，也能正常运行。就是多了一个警告。但是要注意了，对于内置类型没有啥太大影响，但是对于自定义类型，那就会直接报错
其实在new的过程中，我们也可以顺便进行初始化。
初始化的时候，对于内置类型则为加上括号。对于数组内置类型，则为花括号初始化
在这里插入图片描述注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用
new[]和delete[]，注意：匹配起来使用。

2.C++为什么要搞new和delete

这是因为祖师爷早就看不惯原来C语言的写法了
当我们想要手撕一个链表的时候，如果我们使用C语言的方法，思路很简单，但是太啰嗦了。并且C语言的那一套不满足我们的需求

typedef struct ListNode
{
	struct ListNode* next;
	int val;
}ListNode;
struct ListNode* BuyListNode(int x)
{
	struct ListNode* tmp =(struct ListNode*)malloc(sizeof(struct ListNode));
	if (tmp == NULL)
	{
		perror("malloc is fail\n");
		return NULL;
	}
	tmp->next = NULL;
	tmp->val = x;
	return tmp;
}
int main()
{
	ListNode* n1 = BuyListNode(1);
	ListNode* n2 = BuyListNode(2);
	n1->next = n2;
	return 0;
}

而c++的方法就很绝，太香了

typedef struct ListNode
{
	struct ListNode* next;
	int val;
	ListNode(int x = 0)
		:next(nullptr)
		,val(x)
	{}
}ListNode;
struct ListNode* BuyListNode(int x)
{
	struct ListNode* tmp =(struct ListNode*)malloc(sizeof(struct ListNode));
	if (tmp == NULL)
	{
		perror("malloc is fail\n");
		return NULL;
	}
	tmp->next = NULL;
	tmp->val = x;
	return tmp;
}
int main()
{
	ListNode* n1 = BuyListNode(1);
	ListNode* n2 = BuyListNode(2);
	n1->next = n2;

	ListNode* n3 = new ListNode(1);
	ListNode* n4 = new ListNode(2);
	n3->next = n4;
	return 0;
}

在这里插入图片描述我们只需要写一个构造函数就可以了。非常的简单，极大的简化了代码。因为new是开空间+构造函数初始化。内置类型本来就是不做任何处理的。

我们可以发现new和malloc在用法上没有任何区别，但是new可以进行初始化。

3.C++中new和delete操作自定义类型

new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间，还会调用构造函数和析构函数

我们先简单的随便写一个类

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;

	return 0;
}

我们进行调试
在这里插入图片描述
如果是对于一个数组而言的话，可以看到是调用10次构造函数，10次析构函数

同样的，如果我们非要使用对于数组的释放不带上[]，那么必然造成内存泄漏，见下面代码，可见vs2022检查相对严格。直接报错。它只调用了一次析构函数
在这里插入图片描述现在我们知道了，new的时候会调用默认构造函数，那么我们就不让它有默认构造函数，又会发生什么事情呢？

果然报错了。我们知道，在对象实例化的时候，没有默认构造，但是有构造函数，我们就需要传参数，那么这里我们能否传参数呢？，其实是可以的
不过在此我们需要注意的是，我们这里由于是调用n次构造函数，所以后面的参数个数必须与数组元素个数相匹配，否则存在一些对象就会想要调用默认构造函数，而没有默认构造函数产生的错误
这里其实我们是直接给常量的，是存在一些隐式类型转换的。
在这里插入图片描述我们也可以这样给参数，直接给A的匿名对象

直接给对象的好处是可以防止多参数。

提到了隐式类型转换。我们不禁想到在前面我们说过，在对象的实例化的时候，会在同一行中连续出现构造拷贝构造的组合。那么这里是否又会产生一些构造和拷贝构造的优化呢？
我们在一开始只是用1，2，3，4这样进行赋值的时候。编译器又会发生一些什么现象呢？

如下所示，这本应是正常情况，用1先构造出一个临时对象，这个临时对象具有常性，所以拷贝构造要加const，然后用这个临时对象继续拷贝构造给A数组。这样就完成一个对象的初始化了。重复四次即可。这是本应该的情况
在这里插入图片描述然而当我们运行的时候，发现结果只有构造，而无拷贝构造。这其实是在上一篇中我们提到过的编译器的一些优化
也即构造+拷贝构造-->构造

那么对于直接使用A(1)进行初始化又会发生什么呢？如下所示，这是我们推测的本应该有的情况
在这里插入图片描述
然后编译器再次优化。构造+拷贝构造合二为一变成了构造

我们继续来进行探讨，上面是没有默认构造，我们不得不这样做，那么如果有了默认构造呢？我们仍然可以向上面这样做。这样的好处是，我们就可以像数组一样，前面给了参数的，利用参数去构造，没有参数，那就通过缺省值来默认构造
在这里插入图片描述

4.非要乱用delete和free会造成什么后果？

接下来我们继续研究，delete和free乱用又会产生什么样的后果。我们显然知道，我们必须要搭配使用，但是如果要乱用会产生什么样子的后果呢？

首先对于内置类型而言，后果几乎没有什么大影响。随便交叉不会产生太大问题。但是还是不建议这样做
对于自定义类型而言，有可能会产生一些问题。

如下所示是恰巧没有问题

在这里插入图片描述

但是对于下面这个，可就惨喽
在这里插入图片描述

这里我们就不做太深的探讨了，因为同样的代码，在这个编译器上可能会崩溃，而在其他的编译器上不会崩溃，在此笔者呼吁不要乱用！！！我们的原则就是一定要匹配使用，不要乱搞，否则就是不确定的

四、 operator new与operator delete函数

这里我们就涉及到new和delete的底层实现了

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

如下面代码所示：这是从库里面扒出来的代码。这里我们可能暂时看不懂，但是先不要管这么多，这些很多都是和异常相关的。我们来简单的看一下就可以

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。
*/
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);
}
/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void* pUserData)
{
	_CrtMemBlockHeader* pHead;
	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
	if (pUserData == NULL)
		return;
	_mlock(_HEAP_LOCK); /* block other threads */
	__TRY
		/* get a pointer to memory block header */
		pHead = pHdr(pUserData);
	/* verify block type */
	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
	_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK); /* release other threads */
	__END_TRY_FINALLY
		return;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

在这个operator new中，我们注意到了 malloc，可以推测它就是利用malloc去实现某些功能的，如果malloc失败呢，它会做一些东西，也就是抛异常
在这里插入图片描述在operator delete中，我们也可以注意到调用free函数

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

事实上，我们也可以直接在c++直接使用operator new 和operator delete

class A
{
public:
	A(int a=0,int b=0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	A(const A& a)
	{
		cout << "A(const A& a)" << this << endl;;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	A* p1 = (A*)operator new(sizeof(A));
	A* p2 = new A(1);
	operator delete(p1);
	delete p2;

	int* p3 = (int*)operator new(sizeof(int)); 
	int* p4 = new int;
	operator delete(p3);
	delete p4;

	
	return 0;
}

我们可以注意到确实是可以正常的使用
在这里插入图片描述
我们可以注意到，事实上，operator new 和operator delete和malloc与free是非常之相似的。但是他们也是存在一些区别的

我们知道：

malloc是直接开空间
new 是开空间+构造函数

所以new的开空间的过程就是malloc的过程。
但是又有一个问题，面向对象的语言不喜欢返回值，更喜欢抛异常，C语言确喜欢返回错误码

我们可以去测试一下

我们先来测试一下vs最多可以申请多少内存的空间，我们前面都是64位环境，我们在这里为了方便一点，先改为x86环境

int main()
{
	int* p1 = nullptr;
	do
	{
		int* p1 = (int*)malloc(1024 * 1024);
		cout << p1 << endl;
	}while(p1);

	return 0;
}

一开始是这样的
在这里插入图片描述当我们申请结束后，差不读2G的空间，这里的都是虚拟内存，可见32位下本来就4G空间，最多2G空间
上面是对于malloc的，对于new，它会抛异常
我们可以先捕获一下异常，当出现异常的时候，会直接跳转到catch
在这里插入图片描述

经过上面的分析，我们得知了，new开空间的过程不可以直接调用malloc，因为C++需要抛异常

我们在回过头来看operator new的源代码，实际上就是对于malloc的封装，当malloc失败的时候，抛异常
在这里插入图片描述

所以new在开空间的过程会调用operator new，operator new 又会调用malloc，然后才去调用构造函数
我们同理可以推出delete和free的关系
在这里插入图片描述我们也可以直接跳转到反汇编来观察代码
我们在观察一下delete
需要注意的是，当前的编译器将析构和operator delete又封装了一层函数，我们可能直接观察不到我们一路F11就可以看到里面的析构和operator delete
在这里插入图片描述
到了这里我们也就成功的理解了new和delete的底层了

五、operator new和operator delete的实现原理

1.内置类型

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

2.自定义类型

new的原理：

调用operator new函数申请空间
在申请的空间上执行构造函数，完成对象的构造

delete的原理：

在空间上执行析构函数，完成对象中资源的清理工作
调用operator delete函数释放对象的空间

new T[N]的原理：

调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对
象空间的申请
在申请的空间上执行N次构造函数

delete[]的原理：

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

3.栈

我们现在再来回过头来看一下栈

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack(size_t capacity = 3)" << endl;

		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	DataType* _array;
	int       _capacity;
	int       _size;
};

int main()
{
	try
	{
		// 需要申请一个堆上的栈对象
		Stack* p1 = new Stack;
		delete p1;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

我们就可以理解这里的一些做法，我们先定义一个栈指针，我们可以直接new一个栈，这样刚好也就调用了构造函数，然后我们清理的时候这里先调用析构然后再释放。必须得按照这个步骤来，否则会出现问题.
如下图所示，我们会发现我们再new的时候，必须先开辟空间，然后才可以构造函数。再delete的时候，我们必须先析构函数，清理资源。然后才可以释放空间
在这里插入图片描述
这样的话我们就发现，我们以后就可以直接使用new了，不需要做任何检查，因为可以有异常的检查。

六、定位new表达式（placement-new）

1.定位new的使用

`定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象``
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表

这里的p是一个指针，是一个内置类型，不会自动调用构造和析构。所以我们就需要显示调用，就需要定位new表达式

实际上其实就是我们malloc或者operator以后，我们需要此时只完成了new的一半功能，也就是开空间，接下来我们还需要调用构造函数，那么为了调用这个构造函数，我们可以new（p）A显式调用new。然后可以利用这个指针去调用析构函数。然后就可以释放掉空间，模拟new 和delete的功能。

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

2.池化技术

实际上，定位new一半应用于池化技术
什么是池化技术呢？如下图所示，假设是一个山，山顶的和尚们要喝水的话需要下山上山，但是这样太耽搁时间了，所以建造了一个风车将水都运到山上去，形成一个小池，提高了效率
在这里插入图片描述我们一般有：内存池，线程池，连接池等

3.在内存池的应用

内存池就是我们如果需要频繁大量的使用堆区的内存，由于new的话还是比较麻烦的，所以我们就建立一个内存池，先将一部分内存放到这，就可以快速的去申请内存了
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
这里就比较复杂了，比如在STL库中就会有应用。

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

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是

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

八、内存泄漏

1. 什么是内存泄漏，内存泄漏的危害

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

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;
	// 2.异常安全问题
	int* p3 = new int[10];
	Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
	delete[] p3;
}

2.内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：

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