🍅不同的数据放在不同的地方，需要内存管理

目录

☃️1.C/C++中的内存分布

☃️2.C语言中动态内存管理方式

☃️3.C++内存管理方式

🐝3.1  new/delete操作内置类型

🐝3.2 new和delete操作自定义类型

🐝3.3 operator new与operator delete函数

🐝3.4 定位new表达式(placement-new)

☃️4.内存泄漏

🐝4.1 什么是内存泄漏，内存泄漏的危害

🐝4.2 内存泄漏分类（没有搭配使用不一定会导致内存泄漏）

🐝4.3 如何检测内存泄漏

🐝4.4 如何避免内存泄漏

---

☃️1.C/C++中的内存分布

int globalVar = 1;

static int staticGlobalVar = 1;

int main()

{

	static int staticVar = 1;

	int localVar = 1;

	int num1[10] = { 1, 2, 3, 4 };

	char char2[] = "abcd";

	char* pChar3 = (const char *)"abcd";

	int* ptr1 = (int*)malloc(sizeof(int) * 4);

	int* ptr2 = (int*)calloc(4, sizeof(int));

	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);

	free(ptr1);

	free(ptr3);

}

 首先看一段C代码（sizeof和strlen），明确概念

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

 对应到上面的各个变量

尤其注意，char2是字符串数组，里面存储“ancd/0”

pChar3是一个指针，指向常量字符串（不可修改）

 

☃️2.C语言中动态内存管理方式

malloc/calloc/realloc 和free配套

void Test ()
{
int* p1 = (int*) malloc(sizeof(int));
free(p1);
//malloc/calloc的区别是会不会初始化
//malloc是开辟空间/realloc是扩容
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
// 不需要free(p2)，p3就是在p2后扩容的。直接一起释放掉p3即可
free(p3 );
}

还是注意到这张图 的Heap（堆）

 对malloc和free两个函数的深层次讲解（略去基本的用法）

即使申请0字节内存，malloc还是会分配一个最小的chunk（内存块）

这俩函数底层是使用两个系统调用：brk（）和mmap（）

（注意：申请内存的时候Linux内核只会先分配一段虚拟内存，真正使用的时候才会映射到物理内存去）

只看这一小段，一开始heap的起点（start_brk）和终点（program break简称brk）指向同一个地方，

brk（）通过增加break location来获取内存

每次开辟一些空间Heap的面积（蓝色）变大（向上生长）

ASLR(操作系统中使用的一种安全技术）关闭时，起终点指向data/bss段的末尾，也就是end_data

ASLR开启时，起终点指向end_data加上一段随机的brk偏移

 注意：sbrk（）是c的库函数

mmap（）用于创建死哦you的匿名映射段，主要为了分配一段新的内存，这段内存只有调用mmap（）的进程可以使用，所以称之为私有的，与之相反的操作是，munmap（），删除一块内存区域上的映射

☃️3.C++内存管理方式

通过new和delete操作符进行动态内存管理

🐝3.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;
}

大家注意一下格式就好 

（x）圆括号里面的数字代表初始化成x

[ x ] 方括号里面代表开辟类型的个数

注意new和delete的对应

🐝3.2 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()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
	//还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
	// 内置类型是几乎是一样的
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;
	free(p3);
	delete p4;
	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
	return 0;
}

class Stack
{
public:
	Stack()
	{
		cout << "Stack()" << endl;
		_a = new int[4];
		_top = 0;
		_capacity = 4;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		delete[] _a;
		_top = _capacity = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st;
	Stack* ptr = new Stack;
	delete ptr;
	return 0;
}

 先析构销毁给_a开辟的，再调delete销毁栈对象

🐝3.3 operator new与operator delete函数

operator new和opeator delete是系统提供的全局函数（不是运算符重载.....）

new底层原理是调用operator new全局函数来申请空间

delelte同理

operator new：实际通过malloc（申请空间），当malloc申请成功时直接返回

申请失败时，执行空间不足的对应措施，如果该对应措施 用户设置过，则直接执行，否则 抛异常

说白了它就是malloc的封装，祖师爷嫌弃malloc还要检查（个别编译器），开空间之后，调用构造函数

delete先调用析构函数，完成对象中资源的清理工作，然后释放空间

new int[10] 申请空间的底层：call operator new[] ——> operator new——>再调用十次析构

delete[10] ：10次析构函数，完成10个对象中资源的清理——>call operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间 

🐝3.4 定位new表达式(placement-new)

定位new需要头文件#include <new>

#include <new>
int main()
{
	const int N = 4;
	char buffer[500];

	int* p1 = new int[N] ; //正常的new
	int* p2 = new(buffer) int[N]; //定位new，从buffer指针开始开辟内存
	cout <<"buffer的地址：" << &buffer << endl;
	for (int i = 0; i < N; i++)
	{
		cout << "p2[i]的地址：" << &p2[i] << endl;
	}
	return 0;
}

 那么定位new会不会覆盖？

#include <new>
int main()
{
	const int N = 4;
	char buffer[500];

	int* p1 = new int[N] ; //正常的new
	int* p2 = new(buffer) int[N]; //定位new，从buffer指针开始开辟内存
	cout <<"buffer的地址：" << &buffer << endl;
	for (int i = 0; i < N; i++)
	{
		cout << "p2[i]的地址：" << &p2[i] << endl;
	}
	cout << "====================" << endl;
	int* p3 = new int[N]; //正常的new
	int* p4 = new(buffer) int[N]; //定位new
	cout << "buffer的地址：" << &buffer << endl;
	for (int i = 0; i < N; i++)
	{
		cout << "p3[i]的地址：" << &p2[i] << endl;
		cout << "p4[i]的地址：" << &p2[i] << endl;
	}
	return 0;
}

如果不想要覆盖

#include <new>
int main()
{
	const int N = 4;
	char buffer[500];

	int* p1 = new int[N] ; //正常的new
	int* p2 = new(buffer) int[N]; //定位new，从buffer指针开始开辟内存
	cout <<"buffer的地址：" << &buffer << endl;
	for (int i = 0; i < N; i++)
	{
		cout << "p1[i]的地址：" << &p1[i] << endl;

		cout << "p2[i]的地址：" << &p2[i] << endl;
	}
	delete[] p1;
	cout << "====================" << endl;
	int* p3 = new int[N]; //正常的new
	int* p4 = new(buffer) int[N]; //定位new
	cout << "buffer的地址：" << &buffer << endl;
	for (int i = 0; i < N; i++)
	{
		cout << "p3[i]的地址：" << &p3[i] << endl;
		cout << "p4[i]的地址：" << &p4[i] << endl;
	}
	cout << "====================" << endl;
	int* p5 = new int[N]; //正常的new
	int* p6 = new(buffer+N*sizeof(int )) int[N]; //定位new
	cout << "buffer的地址：" << &buffer << endl;
	for (int i = 0; i < N; i++)
	{
		cout << "p5[i]的地址：" << &p5[i] << endl;
		cout << "p6[i]的地址：" << &p6[i] << endl;
	}
	return 0;
}

 

☃️4.内存泄漏

🐝4.1 什么是内存泄漏，内存泄漏的危害

内存泄漏指因为疏忽或错误  造成  程序没有释放不再使用的内存

内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对
该段内存的控制，因而造成了内存的浪费。

危害：长期运行的程序出现内存泄漏，影响很大

如操作系统、后台服务等等 响应越来越慢，最终卡死

🐝4.2 内存泄漏分类（没有搭配使用不一定会导致内存泄漏）

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

堆内存泄漏(Heap leak)

程序执行中依据需要分配，通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉

假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

（说白话，就是malloc / calloc / realloc 没有搭配free， new没有搭配delete）

---

 注： 没有搭配使用不一定会导致内存泄漏

不会报错，因为对于内置类型，没有析构函数，所以delete此时的底层实现就是free，只不过开辟失败的时候会有区别（new是抛异常）

#define _CRTDBG_MAP_ALLOC

class Stack
{
public:
	Stack()
	{
		cout << "Stack()" << endl;
		_a = new int[4];
		_top = 0;
		_capacity = 4;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		delete[] _a;
		_top = _capacity = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	//int* p = new int[10];
	//free(p);
	Stack* p = new Stack;
	free(p);
	_CrtDumpMemoryLeaks();
	return 0;
}

 这个内存泄漏就是看你的类中析构函数有没有释放内存的操作，如果有（比如像栈的实现）那就完了，会内存泄漏，否则可苟活

结论：new/malloc系列  底层实现机制有关联交叉，不匹配，使用可能有问题，为了不埋雷，还是尽可能规范使用

---

系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放
掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

🐝4.3 如何检测内存泄漏

在vs下，可以使用windows操作系统提供的_CrtDumpMemoryLeaks() 函数（#define _CRTDBG_MAP_ALLOC 要加上这个宏）进行简单检测，该
函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息

可参考内存泄漏工具比较

🐝4.4 如何避免内存泄漏

1、事前预防型。如智能指针等

2、事后查错型。如泄漏检测工具