从零开始c++精讲:第三篇——内存管理

发布时间:2024年01月20日


一、C/C++内存分布

为什么要有内存区域的划分呢?
因为不同数据有不同的存储需求,各区域满足不同的需求。
在这里插入图片描述

栈(堆栈):一般存放临时用的,比如非静态局部变量/函数参数/返回值等,栈是向下增长的。

:有动态使用的需求,需要的时候你给我,不需要的时候你释放。也就是出了函数作用域,这个变量不会自动销毁,只有我不需要它了才销毁。

数据段(静态区):需要长期使用/整个运行期间都使用的。比如全局数据或静态数据。

代码段(常量区):只读数据不修改。比如可执行代码/只读常量。

内存映射段:是高效的I/O映射方式,用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存,做进程间通信。(Linux课程如果没学到这块,现在只需要了解一下)

实战演练
在这里插入图片描述

在这里插入图片描述
globalval:是全局变量,在静态区

staticGlobalVal:被static修饰的全局变量,还是在静态区
ps:globalval和staticGlobalVal的区别是在链接属性,globalval可在各个文件可用,staticGlobalVal只在当前文件可用

staticVal:被static修饰的局部变量,还是在静态区
ps:staticGlobalVal可在当前文件用,staticVal只能在所处函数中用。
但是对于生命周期而言,globalval和staticGlobalVal和staticVal是一样的

localVar:一个简单的临时变量,存储在栈上,没啥好说的

num1:虽然是个数组但也是一个临时变量,存储在栈上

char2:这个和num1类似的,都是数组,只不过类型变了。还是存储在栈上

*char2:相当于把指针指向内容解引用,数组上的元素还是在栈内的。

pchar3:是一个指针,定义在栈上。这里的const修饰的是指针指向的内容,不是修饰的指针。

*pchar3:是指针指向的内容,而指针指向的内容是被const修饰的,它是在常量区的
在这里插入图片描述

ptr1:本身是一个栈上的变量,它指向一个堆上的空间

*ptr1:是指针的解引用,指针是指向堆的,解引用就是堆那片空间。

在这里插入图片描述

二、C语言中动态内存管理方式:malloc/calloc/realloc/free

void Test ()
{
int* p1 = (int*) malloc(sizeof(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 );
}

三、C++中动态内存管理

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

int main()
{
	int* p1 = new int;// 动态申请一个int类型的空间

	int* p2 = new int[10];//申请10个空间
	
	//ps:内置类型默认不初始化,只是单纯开空间

	//如果想初始化,则单个数据加圆括号,多个数据加花括号,括号里面附上初始化内容
	int* p3 = new int(1);
	int* p4 = new int[3]{1,2,3};
	int* p5 = new int[10]{ 1,2,3 };//初始化的数量不够整个数组大小,则剩下的默认是0

	delete p1;
	delete[] p2;
	delete p3;
	delete[] p4;
	delete[] p5;

	return 0;
}

在这里插入图片描述
ps:c++的new比起c语言的malloc的好处在哪里1?
malloc不方便动态申请自定义对象的初始化问题。
new更方便自定义类型的初始化
在这里插入图片描述

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

int main()
{
	//malloc不方便动态申请自定义对象的初始化问题
	A* p1 = new A;//自定义类型,不给参数调用默认构造函数
	A* p2 = new A(1);//给了参数,调用所给参数的构造函数

	//初始化多个对象
	//法一:
	A aa1(1);
	A aa2(2);
	A aa3(3);
	A* p3 = new A[3]{aa1,aa2,aa3};

	//法二:匿名对象的方法
	A* p4 = new A[3]{ A(1),A(2),A(3) };

	//法三:让编译器自己去调构造函数
	A* p5 = new A[3]{ 1,2,3 };

	delete p1;//delete会调用析构函数+释放空间
	delete p2;
	delete[] p3;
	delete[] p4;
	delete[] p5;
	return 0;
}

在这里插入图片描述

再举个例子:

struct ListNode
{
	int _val;
	ListNode* _next;

	ListNode(int val)
		:_val(val)
		, _next(nullptr)
	{}
};

int main()
{
	//相比c语言,c++就不用再写什么createNode函数了,你之间用new开空间就行
	ListNode* n1 = new ListNode(1);
	ListNode* n1 = new ListNode(2);
	ListNode* n1 = new ListNode(3);
}

ps:内置类型的对象申请释放,new和malloc除了用法,其他没有区别。但是自定义类型,new可以自己初始化。

对于自定义类型,new和delete会自动开空间,也会自动调构造和析构函数
在这里插入图片描述

class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "Stack(int capacity=4)" << endl;
		_a = new int[capacity];
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		delete[] _a;
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack s1;

	Stack *p1 = new Stack;//也可以直接开辟一个栈的大小(指针4字节,加两个4字节的int)
	return 0;
}

你也可以直接new一个Stack大小的空间,然后用p1指向这块空间,内存中情况如下:
p1指向这个对象大小的空间,然后构造函数里的a又new了一块数组。
在这里插入图片描述
而在调delete的时候,是先清理构造函数请求的那块空间,也就是_a指向的空间。然后再释放栈对象(也就是p1指向的空间)。否则你先把栈对象释放了,那栈对面里面的_a指向的空间就找不到了。

在这里插入图片描述
在这里插入图片描述

四、operator new与operator delete函数

4.1 operator new与operator delete函数(重点)

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

operator new 和operator delete库里的全局函数,封装了malloc和free

class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "Stack(int capacity=4)" << endl;
		_a = new int[capacity];
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		delete[] _a;
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	//Stack *p1 = new Stack;//也可以直接开辟一个栈的大小(指针4字节,加两个4字节的int)
	//delete p1;

	Stack* p2 = (Stack*)operator new(sizeof(Stack));
	operator delete(p2);
	//p2这种用法功能是和C语言的malloc和free是一样的
	//operator new不会调用构造,operator delete也不会调用析构
	return 0;
}

在这里插入图片描述
operator new 和operator delete功能上和malloc和free功能上是一样的,但是如果开空间或者销毁空间失败之后,是抛异常的,这是C语言的malloc和free没有的。

另外,如果你是开一个自定义类型的数组,它会自动给你开辟一个sizeof(自定义类型)*数量的空间大小

在这里插入图片描述
后面调用delete,会先调用10次析构函数(会先让p3往前4个字节,找到要析构几次的值,这里是10),再往后就是调用operate delete[ ](ps:operate delete[ ]内部又会调用10次operate delete,然后是更底层的free函数)

在这里插入图片描述

五、new和delete的实现原理

5.1内置类型

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

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

六、定位new表达式(placement-new)(了解)

在这里插入图片描述

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A; // 注意:如果A类的构造函数有参数时,此处需要传参
	p1->~A();
	free(p1);
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

七、常见面试题

7.1 malloc/free和new/delete的区别

在这里插入图片描述

7.2内存泄漏

在这里插入图片描述
在这里插入图片描述



文章来源:https://blog.csdn.net/m0_57180439/article/details/135686344
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。