详细说明C和C++内存管理的相同点与不同点

---

1.C++内存分布

我们先来看一段代码

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
	static int staticVar = 1;
	int localVar = 1;
	int num1[10] = { 1, 2, 3, 4 };
	char char2[] = "abcd";
	char* pChar3 = "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);
}

这几道题码友们先做做看，下面会有答案哦！

1. 选择题：
   选项: A.栈 B.堆 C.数据段 D.代码段
   globalVar在哪里？____ staticGlobalVar在哪里？____
   staticVar在哪里？____ localVar在哪里？____
   num1 在哪里？____
   char2在哪里？____ *char2在哪里？___
   pChar3在哪里？____ *pChar3在哪里？____
   ptr1在哪里？____ *ptr1在哪里？____
2. 填空题：
   sizeof(num1) = ____;sizeof(char2) = ____; strlen(char2) = ____;
   sizeof(pChar3) = ____; strlen(pChar3) = ____;
   sizeof(ptr1) = ____;

经过上图分析，想必大家都对c/c++内存管理更加了解了。下面来看上题的答案

1. 选择题：
   选项: A.栈 B.堆 C.数据段 D.代码段
   globalVar在哪里？C staticGlobalVar在哪里？C
   staticVar在哪里？C localVar在哪里？A
   num1 在哪里？A
   char2在哪里？A *char2在哪里？A
   pChar3在哪里？A *pChar3在哪里？D
   ptr1在哪里？A *ptr1在哪里？B
2. 填空题：
   sizeof(num1) = 40;sizeof(char2) = 5; strlen(char2) = 4;
   sizeof(pChar3) = 4; strlen(pChar3) = 4;
   sizeof(ptr1) = 4;

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

2.1 c++内存管理方式

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

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

	//c++
	int* p3 = new int;
	//int* p3= new int(10);初始化为10
	int* p4 = new int[10];
	delete p3;
	delete[] p4;

	return 0;
}

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

细心的朋友一定会有疑问，既然malloc free还可以在c++中使用，那为什么还需要有new 和delete？
1.对于内置类型-----效果一样(申请空间，释放空间）
2.对于自定义类型-----效果不一样(申请空间+构造函数初始化，释放空间+调用析构函数)

//有了malloc和free  new和delete的意义何再？
//1.对于内置类型，效果一样
//2.对于自定义类型，效果不一样

class A
{
public:
	A()
	{
		_a = 10;
		cout << "A" << endl;
	}
	~A()
	{
		cout << "~A" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p1 = (A*)malloc(sizeof(A));//申请空间
	A* p2 = new A;//申请空间+构造函数初始化

	free(p1);//释放空间
	delete p2;//释放空间+析构函数
	return 0;
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

3.operator new与operator delete函数

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

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

int  main()
{
	A* p1 = (A*)malloc(sizeof(A));
	//A* P2 = new A;
	A* p3 = (A*)operator new(sizeof(A));

	//operator new 和malloc的区别？
	//结论：使用方式是一样的，但是处理错误的方式是不一样的

	size_t size = 2;
	void* p4 = malloc(size * 1024 * 1024*1024);
	cout << p4 << endl;//失败返回0;

	try{
		void* p5 = operator new(size * 1024 * 1024 * 1024);//会报错
		cout << p5 << endl;
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}


	//malloc
	//operator new==>malloc+失败抛异常实现
	//new         ==>operator new+构造函数
	//operator delete和delete是一样的
	return 0;
}

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

区别：
malloc
operator new==>malloc+失败抛异常实现
new ==>operator new+构造函数
operator delete和delete是一样的

4.new和delete的实现原理

4.1 内置类型

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

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

5 定位new表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
相当于：new= operator new()+定位new表达式
使用格式：
new (place_address) type 或者 new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定位表达式进行显示调构造函数进行初始化.

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

int main()
{
	A*p1 = new A;
	delete p1;

	//想模拟上述行为
	A*p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);//相当于就是在存在的空间调用构造函数初始化，定位new
	//new(空间的指针)类型(参数)

	p2->~A();
	operator delete(p2);
}

6.内存泄漏

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

内存泄漏非常常见，解决方案分为两种：
1、事前预防型。如智能指针等。
2、事后查错型。如泄漏检测工具。