C/C++内存管理

1. C/C++内存分布

int globalvar = 1;
static int staticGlobalvar = 1;
void Test()
{
	static int staticVar = 1;
	int localvar = 1;

	int num[10] = { 1,2,3,4 };
	char char2[] = "abcd";
	const char* pChar3 = "abcd";
	int* ptr1 = (int*)malloc(sizeof(int) * 4);
	int* ptr2 = (int*)malloc(4, sizeof(int));
	int* ptr3 = (int*)relloc(ptr2, sizeof(int) * 4);
	free(ptr1);
	free(ptr3);
}

• 选项：A. 栈 B.堆 C.数据段（静态区） D.代码段（常量区）
• globalvar:____ - staticGlobalar:_____ -staticVar:______
• localVar:_____ - num1:____
• char2:_____ - *char2:_____
• pChar3:____ - *pChar3:____
• ptr1:____ - *ptr1:_____
  C C C A A A A A D A B
• sizeof(num1)=____ - sizeof(char2)=____ - strlen(char2)=______
• sizeof(pChar3)=____ - strlen(pChar3)=____ - sizeof(ptr1)=______
  40; 5; 4(遇见\0截止）; 4/8（是一个指针，和后面指向的东西没有关系，32位4，64位8）; 4（有效字符的个数）; 4/8（指针）
  

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

2. C语言中动态内存管理方式：malloc/calloc/realloc/free

void Test()
{
	int* p1 = (int*)malloc(size(int));
	free(p1);

	//1.malloc/calloc/realloc的区别？
	int* p2 = (int*)calloc(4, sizeof(int));
	int* p3 = (int*)realloc(p2, sizeof(int) * 10);

	//这里需要free(p2)嘛？
	free(p3);
}

3.C++内存管理方式new/delete

不推荐malloc和free，C++的new/delete更简洁，对内置类型差别不大，自定义类型会调用构造函数和析构函数。

3.1 new/delete操作内置类型

int main()
{
	int* p1 = new int;//new不用检查，不会初始化。
	int* p2 = (int*)malloc(sizeof(int));//要去强转，VS2019检查严格
	if (p2 == nullptr)
	{
		perror("malloc fail");
	}
	return 0;
}

int* p3=new int(0);//初始化为0
delete p3;
int* p4=new int[10];//申请了10个int的数组
delete[] p4;
int* p5=new int[10]{1,2,3,4};//初始化

new可以帮助初始化

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;
}

new一定要去匹配使用，不要交叉，否则结果不确定。

3.2 new/delete操作自定义类型

单个对象调单次构造函数，多个对象调多次构造函数。delete调析构函数
根本上而言，C和C++内存管理用一套模式

4. operator new和operator delete函数（重点）

4.1底层原理

库里面的全局函数operator new和operator delete，不是运算符重载。本质是malloc和free的封装。
new和delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是全局函数。new在底层调用delete new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间

int main()
{
	//出错机制不同
	//失败以后抛异常
	int* p1=(int*)operator new(sizeof(int*));
	//失败返回空nullptr
	int* p2 = (int*)malloc(sizeof(int*));
	if (p2 == nullptr)
	{
		perror("malloc fail");
	}

	//面向对象的语言处理错误时基本上使用抛异常。
	//new 1.申请空间 operator new,封装malloc 2.调用构造函数
	A* p3 = new A;//调用operator new
	
	//delete需先调用析构函数，在使用p3指向的空间
	delete p3;
	
    //申请空间 operator new[]->operator new->封装malloc
    //调用10次构造函数
	A* p6 = new A[10];
	delete[] p6;
    //delete需先调用10次析构函数，在使用operator delete[] p6指向的空间

    int* p7 = new int[10];
	free(p7);
	//不会造成内存泄露，因为针对的是内置类型,不会报错
	A* p8 = new A;
	free（p8）;
	//不会报错。operator delete->free,只是没有调用析构函数，少调不会报错
	
	return 0;
}

class Stack
{
public:
	Stack()
	{
		cout << "Stack()" << endl;
		_a = new int[4];
		_top = 0;
		_capacity = 4;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
Stack st;
//调用构造，会调用析构

Stack* pst = new Stack;//指针，内置类型，不调用析构
//pst：4个字节，是个指针。new的机制：开空间，12个字节，开在堆上面，再调用构造函数，再去堆上开16个字节，也就是4个整型
delete pst;

1. 先调用析构函数，完成栈指向的资源的清理
2. 调用operator delete（pst），释放结构对象的空间。
3. 由于底层的实现有关联交叉，不匹配使用可能有问题可能没有问题，因此最好要匹配使用

A* p9=new A[10];
free(p9);//报错
delete p9；//报错
delete[] p9;//没有问题

了解其底层机制

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

• 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在释放空间前会调用析构函数完成空间中资源的清理。
   用法+底层原理

int main()
{
	size_t size = 0;
	while (1)
	{
		int* p1 = (int*)malloc(1024 * 1024 * 4);

		if (p1 == nullptr)
		{
			break;
		}
		size += 1024 *1024* 4;
		cout << p1 << endl;
	
}
	cout << size << endl;
	cout << size/1024/1024 << "MB"<<endl;

}

C++出错抛异常。

int main()
{
	size_t size = 0;
	try
	{
		while (1)
		{
			int* p1 = new int[1024 * 1024];

				if (p1 == nullptr)
				{
					break;
				}
			size += 1024 * 1024 * 4;
			cout << p1 << endl;

		}
	}
	catch (const exception& e)
	{
		cout << e.what()<< endl;
	}
	
	cout << size << endl;
	cout << size/1024/1024 << "MB"<<endl;

}

bad allocation：申请内存失败。

6. 定位new表达式（placement-new）

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

int main()
{
	A aa;
	A* p1 = (A*)malloc(sizeof(A));
	if (p1 == nullptr)
	{
		perror("malloc fail");
	}//构造函数不能显式调用
	//对一块已有的空间初始化——定位new
	//new(p1)A;
	//定位new
	new(p1)A(1);//需要有参数
    //调用析构函数：
	p1->~A();
	free(p1);
	return 0;
}

//改进malloc
A* p2 = new A;
delete p2;

有一类场景需要这个malloc，需要提升性能，内存从内存池进行申请