C/C++内存管理

1. 不同内存区域划分

C/C++内存区域分别有：内核空间、栈、堆、内存映射段、代码段、数据段，他们分别存储

内核空间：程序内存一般为4G，1G为内核空间这个区域用户不能读写，3G为用户空间时用户可                      以操作的

栈：栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的

堆：堆用于程序运行时动态内存分配，如:malloc, new创建的变量都是保存在堆上，堆是可以上           增长的

代码段：可执行的代码/只读常量，如：字符串常量

数据段：存储全局数据和静态数据，如：static成员

内存映射段：内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系                        统接口 创建共享共享内存，做进程间通信

接下来看一段代码解释内存存储原理

int globalVar = 1;//全局数据在数据段(静态区)
static int staticGlobalVar = 1;//全局静态数据在数据段(静态区)

void Test()
{
	static int staticVar = 1;//局部静态数据在数据段(静态区)

	int localVar = 1;//局部变量在栈区

	int num1[10] = { 1, 2, 3, 4 };//num1为数组名代表整个数组,在栈区

	char char2[] = "abcd";//char2为数组名代表整个数组,在栈区
	                      //char2做运算代表首元素地址,所以*char2代表首元素'a',存储在栈区

	const char* pChar3 = "abcd";//这种写法代表该指针指向常量字符串,所以pChar3为局部变量,在栈区
	                            //*pChar3为首元素地址,在代码段(常量区)

	int* ptr1 = (int*)malloc(sizeof(int) * 4);//ptr1表示指向在堆上开辟内存元素首元素的指针,所以ptr1是局部变量,在栈区
	                                          //*ptr1表示首元素地址,在堆区(malloc的元素在堆区)
	int* ptr2 = (int*)calloc(4, sizeof(int));
	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);

	free(ptr1);
	free(ptr3);
}

2. C++内存管理 

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

 首先要了解new和delete操作符

1. 申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用

     new[]和delete[]，注意：匹配起来使用

2. 在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与

    free不会

---

2.1 new/delete操作内置类型 

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

int main()
{
	int* p1 = new int;//new 单个元素
	int* p2 = new int[10];// new 多个元素

	delete p1;//delete 单个元素
	delete[] p2;//delete 多个元素

	//申请对象 + 初始化
	int* p3 = new int(1);
	int* p4 = new int[10] {1};
	int* p5 = new int[10] {1, 2, 3, 4, 5};//其余元素默认初始化为0

	delete p3;
	delete[] p4;
	delete[] p5;

	return 0;
}

2.2 new和delete操作自定义类型

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

class A
{
public:
	A(int a1):_a1(a1)
	{
		cout << "A(int a1)" << endl;
	}
	A(int a1, int a2) :_a1(a1), _a2(a2)
	{
		cout << "A(int a1, int a2)" << endl;
	}
	A(const A& a)
	{
		cout << "A(const A& a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
	void Show()
	{
		cout << "_a1 = " << _a1 << endl;
		cout << "_a2 = " << _a2 << endl;
	}
private:
	int _a1;
	int _a2;
};

int main()
{
	A* p1 = new A(1);//自动调用构造函数
	delete p1;//自动调用析构函数

	A* p2 = new A(1, 1);//多参数构造函数

	A aa1 = (1, 1);
	A aa2 = (2, 2);
	A aa3 = (3, 3);
	A* p3 = new A[3] { aa1, aa2, aa3 };//拷贝构造函数

	A* p4 = new A[3]{ A(1,1),A(2,2),A(3,3) };//匿名对象构造

	A* p5 = new A[3]{ {1,1},{2,2},{3,3} };//隐式类型转换,编译器优化可以直接构造

	return 0;
}

 3. operator new与operator delete函数

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

1. operator new: 该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常

2. operator delete:该函数最终是通过free来释放空间的

下面用一段代码实现 new 申请内存失败的检查:

void fun()
{
	int n = 1;
	while (1)
	{
		void* p = new char[1024 * 1024];
		n++;
		cout << p << "->" << n << endl;
	}
}
int main()
{
	try 
	{
		fun();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

4. malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：

1. 都是从堆上申请空间，并且需要用户手动释放。

malloc/free和new/delete的不同点:

1. malloc和free是函数，new和delete是操作符

2. malloc申请的空间不会初始化，new可以初始化

3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，

    如果是多个对象，[]中指定对象个数即可

4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型

5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需 要        捕获异常

6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在      申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间        中资源的清理释放