内存管理C++ - 技术栈

cpp 复制代码

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";//char2指针在栈上，在栈上开一个空间存放abcd，指针就指向这个空间。
const char* pChar3 = "abcd";//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内存简介

栈又叫堆栈 局部变量（非静态）、函数参数、返回值等等，栈是向下增长的。

堆用于程序运行时动态分配内存，堆可以向上增长。

数据段全局数据和静态数据。

代码段 可执行代码和只读常量。

C语言的动态内存管理方式malloc calloc realloc

cpp 复制代码

class A
{
public:
	A(int a1 = 0, int a2 = 0)
		:_a1(a1)
		,_a2(a2)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a1 = aa._a1;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 1;
};
int main()
{
	int* ptr1 = new int(0);
	delete ptr1;

	int* ptr2 = new int[10] {1, 2, 3};
	delete[] ptr2;

	int* ptr3 = new int{ 0 };
	delete ptr3;

	//A* ptr4 = new A;
	//delete ptr4;

	//A aa1(1);
	//A* ptr5 = new A(aa1);
	//delete ptr5;

	//A* ptr6 = new A(1);
	//delete ptr6;

	//A* ptr7 = new A{ 1,4 };
	//delete ptr7;

	//A* ptr8 = new A[3]{ A(1,2),A(4,5)};
	//delete[] ptr8;


	return 0;
}

cpp 复制代码

//struct ListNode
//{
//	int val;
//	ListNode* next;
//
//	ListNode(int x)
//		:val(x)
//		, next(nullptr)
//	{
//	}
//};
int main()
{
	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(1);
	ListNode* n3 = new ListNode(1);
	ListNode* n4 = new ListNode(1);

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;


	return 0;
}

C++的动态内存管理方式new和 delete操作符进行动态内存管理。

cpp 复制代码

int main()
{
	//throw try/catch
	try 
	{
		void* p1 = new char[1024 * 1024 * 1024];
		cout << p1 << endl;

		void* p2 = new char[1024 * 1024 * 1024];
		cout << p2 << endl;

		void* p3 = new char[1024 * 1024 * 1024];
		cout << p3 << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

2operator new和 operator dalete

1operator new

通过调用malloc来申请空间，malloc申请空间成功了以后，直接返回

申请失败以后，执行空间失败的应对措施，如果应对措施用户设置了，则继续申请。否则抛异常。

2operator delete

最终也是通过free来释放内存的。

3new和delete的实现原理

1 内置类型

如果申请的是内置类型的空间 new delete和malloc free 基本相似。

new 申请失败会抛异常，malloc会返回null

new delete申请和删除的是单个元素的空间，而new[] delete[]申请和删除的是一段连续的空间。

2自定义类型

1new的原理

1调用operator new函数申请空间

2在申请的空间上执行构造函数，完成对象的构造。

2delete的原理

1在空间上执行析构函数，完成对象中资源的清理。

2调用operator delete函数释放对象空间

3new[T]的原理

1调用operator new[ ] 函数实际调用调用operator new完成对N个对象空间的申请

2在申请的空间上执行N次构造函数，完成对象的构造。

4delete[T]的原理

1在释放的空间上执行N次析构函数，完成N个对象中资源的清理。

2调用operator delete[ ]释放空间，实际在operator delete[ ]中调用operator delete来释放空间

cpp 复制代码

int main()
{
	int* p1 = new int;
	//free(p1);
	delete p1;



	return 0;
}
class B
{

private:
	int _b1 = 2;
	int _b2 = 2;
};
int main()
{
	B* p2 = new B[10];
	//free(p2);
	A* p3 = new A[10];



	delete[] p2;
	delete[] p3;
	//free(p3);
	return 0;
}

4malloc free 和 new delete的区别

共同点

：都是在堆上申请空间，都需要自己手动释放空间。

区别

1.前两个是函数，后两个是操作符

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

3malloc申请空间需要手动计算大小并传递，new只需后面跟上申请的类型。多个对象在[申请对象的个数]

4malloc申请空间的返回值是void* ，使用时必须强转，new不需要，new后面跟的就是空间类型。

5malloc申请失败，返回的是null，所以使用时必须判空。new不需要，但是new需要捕获异常。

6申请自定义类型时，malloc和free只会申请和释放空间。

new会申请资源后调用构造函数完成对象的初始化。

delete会在释放空间之前调用析构函数完成空间中资源的清理。