一、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的原理
- 调用operator new函数申请空间
- 在申请的空间上执行构造函数,完成对象的构造
delete的原理
- 在空间上执行析构函数,完成对象中资源的清理工作
- 调用operator delete函数释放对象的空间
new T[N]的原理
- 调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对
象空间的申请 - 在申请的空间上执行N次构造函数
delete[]的原理
- 在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理
- 调用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://www.toymoban.com/news/detail-810501.html
文章来源地址https://www.toymoban.com/news/detail-810501.html
到了这里,关于从零开始c++精讲:第三篇——内存管理的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!