【c++】c/c++内存管理

小编个人主页详情<—请点击
小编个人gitee代码仓库<—请点击
c++系列专栏<—请点击
倘若命中无此运，孤身亦可登昆仑，送给屏幕面前的读者朋友们和小编自己!

前言

【c++】类和对象（四）初始化列表 explicit static 友员 内部类 匿名对象书接上文 详情请点击<—
本文由小编为大家介绍c/c++内存管理

一、c语言内存管理

关于c语言内存管理，小编已为大家详细整理在这里了，详情请点击<—

二、一图搞懂c/c++中的程序内存区域划分

三、c++内存管理

c++兼容c语言，所以c语言中的动态内存管理在c++中同样可以适用，但是由于c语言在有些场景无法使用并且使用相对复杂，所以c++提出了独特的内存管理方式new和delete操作符去进行动态内存管理（在堆上进行动态内存管理）

1. new对比malloc，在内置类型上除了用法不同，其它方面没有区别
2. new对比malloc，在自定类型上除了用法不同，new和delete会去调用自定义类型的构造函数进行初始化和析构函数完成资源的清理工作

1. new和delete操作内置类型

new和delete都是进行搭配使用，申请和释放单个空间使用new和delete，申请和释放多个空间，使用new[]和delete[]一定要搭配对应使用

1. 注意：这里不可以与c语言中的malloc和free混搭使用，只能是malloc和free是一对，new和delete是一对

1. new int ，new加空格加类型的方式进行动态申请内存不需要我们手动计算空间大小，返回指针也不需要进行强制类型转换
2. new int(初始化的值) 如果想要进行初始化，就在类型后面加上括号，括号内写用于初始化的值
3. new int[个数] 如果想要申请类型个空间，那么类型后面加上中括号，中括号内写用想要申请类型空间的个数
4. delete 指针变量名 ，delete加空格加指针变量名可以对单个空间进行释放
5. delete[] 指针变量名 ，delete加中括号加空格加指针变量名可以对多个类型空间进行释放
6. 使用delete对空间进行释放后不会对指针置空nullptr

#include <iostream>

using namespace std;

int main()
{
	int* p1 = new int;//申请一个int空间不初始化
	int* p2 = new int(10);//申请一个int空间并初始化为10
	int* p3 = new int[10];//申请十个int空间不初始化
	int* p4 = new int[10]{ 1,2,3,4 };//申请十个int空间初始化，当我们有初始化的
	//值的时候采用我们给出的值，如果没有我们给出的的值，系统默认初始化为0

	delete p1;
	delete p2;
	delete[] p3;
	delete[] p4;
}

进行申请空间

进行释放空间，delete对空间进行释放后不会对指针置空nullptr

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

1. 对于自定义类型new和delete的使用方式和内置类型使用方式类似，小编这里就不展开进行讲解
2. new对于自定义类型，和malloc不同的是，new除了会开空间，new还会调用自定义类型的构造函数完成初始化，delete会调用自定义类型的析构函数完成资源的清理工作，malloc和free不会

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

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

int main()
{
	A* p1 = new A;
	A* p2 = new A(1);
	A* p3 = new A[4];
	A* p4 = new A[4]{1,2,3};

	delete p1;
	delete p2;
	delete[] p3;
	delete[] p4;

	return 0;
}

3. 这里注意，如果申请的自定义类型需要开多个自定义类型空间且没有默认构造函数，需要手动传入参数的时候如果需要传入两个至多个参数，可以使用匿名对象进行传入
4. 并且这时候创建匿名对象然后使用匿名对象对新对象进行调用拷贝构造函数，编译器为了提高效率会优化为直接使用本应该去初始化匿名对象中的实参去构造函数构造新对象

class A
{
public:
	A(int a,int b)
		:_a(a)
		,_b(b)
	{
		cout << "A()" << endl;
	}

	A(const A& a)
		:_a(a._a)
		, _b(a._b)
	{
		cout << "A()" << endl;
	}

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

int main()
{
	A* p4 = new A[2]{A(1,2),A(3,4)};

	delete[] p4;

	return 0;
}

编译器直接进行了优化，调用构造函数完成新对象的初始化

四、operator new和operator delete函数

我们知道c++是面向对象的一门语言，那么对于c语言中malloc失败返回空NULL的形式，在c++中面向对象这一门语言中适用性不是很高，c++希望当申请空间失败的时候直接抛异常终止程序显示错误信息

1. 所以说在c++中有了这种抛异常的机制，对于申请空间不需要再像c语言中进行检查返回值是否为空NULL了

1. new和delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是系统提供的全局函数
2. new在底层通过调用operator new全局函数来申请空间，delete在底层通过调用operator delete全局函数来释放空间
3. operator new函数实际上是通过调用malloc函数完成空间的申请，如果空间正常被申请那么返回，如果空间申请失败，那么抛异常，operator new的使用需要计算申请空间的大小，并且返回值需要强制类型转换
4. operator delete函数实际上是通过调用free函数来释放空间的，其中operator delete函数中还会有多层的检查
   

new底层调用了opeartor new去申请空间

delete底层调用了operator delete去释放空间

五、new和delete的实现原理

1. 内置类型

如果是内置类型，除了使用方式上不同，new/malloc，delete/free大致相同，new/delete申请释放的是单个空间，new[]/delete[]申请释放的是连续空间，其中new申请空间失败会抛异常，malloc申请空间失败会返回空NULL

2. 自定义类型

1. new的原理：先调用operator new函数申请空间，再调用自定义类型的构造函数完成对象的初始化工作
2. delete的原理：先调用自定义类型的析构函数完成对资源的清理工作，再调用operator delete函数释放空间
3. new[]：申请n个类型的空间，是调用operator new[]函数一次（在operator new[]函数中完成调用operator new函数n次）和自定义类型的构造函数调用n次
4. delete[]：释放n个类型的空间，调用自定义类型的析构函数n次，再调用一次operator delete[]函数（在operator delete[]函数中完成调用operator delete函数n次）
   stack

看下面代码，深入理解new和delete调用构造函数和析构函数的优势

class Stack
{
public:
	Stack()
	{
		_a = (int*)malloc(sizeof(int) * 4);
		if (_a == nullptr)
		{
			perror("malloc error");
			return;
		}

		_capacity = 4;
		_top = 0;
	}

	~Stack()
	{
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}

private:
	int* _a;
	int _capacity;
	int _top;
};

int main()
{
	//现在你有一个需求，在堆上申请一个栈空间
	Stack* st = new Stack;
	delete st;

	return 0;
}

进行相比，正是因为有了c++中的new/delete操作符调用构造函数和析构函数的操作，才可以更好的对自定义类型进行更好的内存管理

六、定位new表达式

定位new表达式是在已分配的原始内存空间中调用构造函数去初始化一个对象

1. 使用方法new(指向要初始化空间的指针名) 自定义类型 <----这种方式是使用默认构造函数，不传参
2. 使用方法new(指向要初始化空间的指针名) 自定义类型(初始化值) <----这种方式是使用构造函数，需要进行传参

1. 内存池是系统为了避免频繁在堆上进行动态申请空间，比如在链表中，每次建立节点都要从堆中动态申请内存，通常这个进行申请的路径较长，这种频繁申请的方式会造成效率下降，如果我们提前将堆空间申请出适合大小的一块，放在调用路径的近距离位置，那么每次进行申请就不需要在频繁在堆上进行动态申请空间，而是在调用路径的近距离位置处进行申请动态申请空间，但是这空间是未经过初始化的，并且当这些空间被动态申请完后要继续在堆上申请出适合大小的一块，所以空间的最终来源都是堆，但是这种方式可以提高效率。在某些特殊场景中，为了提高效率，会采用这种内存池方式进行动态申请空间
2. 定位new表达式在实际场景中一般是配合内存池进行使用，因为内存池分配出的空间还没有初始化。对于自定义类型，需要我们使用new定义的表达式显示调用构造函数进行初始化

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

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

int main()
{
	A* p = (A*)operator new(sizeof(A));//p指向的空间大小和A类型对象的大小相同的
	//一块空间，但是这块空间还未调用构造函数进行初始化，所以算不上对象
	new(p)A(10);//定位new表达式显示调用类A类型对象的构造函数进行初始化空间为对象

	p->~A();
	operator delete(p);

	return 0;
}

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

1. 共同点：都是从堆上动态申请空间，并且都需要用户手动释放
2. 不同点（特性+用法+底层）

• malloc/free是函数，new/delete是操作符
• malloc函数动态申请的空间不进行初始化，new动态申请的空间可以进行初始化
• malloc函数在使用的时候需要用户手动计算开辟空间的大小，new不需要，因为new的是空间的类型，如果要开n个类型空间，在类型后面跟上[n]即可
• malloc需要强制类型转换，因为malloc的返回值是void*的，new不需要，因为new的是空间的类型
• 当malloc申请空间失败的时候返回空NULL，所以每次调用malloc函数的时候都要判是否为空，new不需要，因为new申请空间失败的时候会抛异常
• malloc/free在使用的时候仅仅是申请释放空间，对于自定义类型，并不会调用其对应的构造函数和析构函数，new/delete在使用的时候不仅会申请释放空间，而且还会调用对应自定义类型的构造函数在申请空间后完成初始化工作，调用析构函数在释放空间前完成对应的资源清理工作

八、内存泄露

内存泄露是指在程序中因为疏忽或错误造成未能释放程序已经不再使用的内存
危害：

1. 普通程序，内存泄露，在进程结束后会操作系统会对资源进行回收，影响不大
2. 长期运行的程序，内存泄露危害很大，会造成程序越来越卡，直到卡死，程序崩溃，比如：游戏服务，操作系统等

总结

以上就是今天的博客内容啦,希望对读者朋友们有帮助
水滴石穿，坚持就是胜利，读者朋友们可以点个关注
点赞收藏加关注，找到小编不迷路！