本篇主要介绍一下C++的内存管理相关知识。C++的内存管理和C语言保持一致。
1.C/C++内存分布
一个程序的数据存储是需要分区的。常见的内存区域划分如下。
我们学C++主要了解栈,堆,数据段,代码段 。
我们先看下面代码和相关问题。
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";
const char* 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);
}
先说答案。
说几个比较容易混淆的,char2和pchar3
2.C语言中动态内存管理方式
C语言中内存管理的方式就是malloc/calloc/realloc/free。详细介绍在【C语言】动态内存管理:malloc、calloc、realloc、free-CSDN博客
3.C++内存管理方式
C语言内存管理方式在C++中可以继续用,但有些地方无能为力,而且用起来比较麻烦 ,因此C++又提出了自己的内存管理方式:通过new和delete操作符进行内存管理。
3.1 new/delete操作内置类型
直接看下面这个代码。
void Test()
{
//管理对象
int* ptr4 = new int;
int* ptr5 = new int(3);
delete ptr4;
delete ptr5;
//管理对象数组
int* ptr6 = new int[3];
delete[] ptr6;
}
C++的new和delete简化了C语言中malloc/calloc/realloc的使用,不用强转,不用求类型大小。
不用了就直接delete,有[]的就用delete[]。
C语言那一套不支持初始化,new出来的对象可以直接初始化。
//数组初始化
int* ptr6 = new int[10] { 0 };
int* ptr7 = new int[10] {1, 2, 3, 4, 5};
3.2 new/delete操作自定义类型
new和delete最主要的是为了让自定义类型用起来方便。拿下面这个A类举例。
class A
{
public:
A(int a = 0) //构造
:_i(a)
{
cout << "A(int a)" << endl;
}
A(const A& a) //拷贝构造
{
cout << "A(const A& a)" << endl;
}
~A() //析构
{
cout << "~A()" << endl;
}
private:
int _i = 1;
};
new一个A类的对象,会直接自动调用它的构造函数,delete时,会直接调用析构函数。
A* p1 = new A;
A* p2 = new A(1);
delete p1;
delete p2;
如果我们想弄一个链表出来,也比在C语言里简单。
struct ListNode //链表的一个节点
{
int val;
ListNode* next;
ListNode(int x)
:val(x)
,next(nullptr)
{}
};
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;
接下来再看看new申请单个对象两个参数的,假如现在有两个参数,如下
class A
{
public:
A(int a1 = 0, int a2 = 0) //构造
:_i(a1)
,_b(a2)
{
cout << "A(int a1 = 0, int a2 = 0)" << endl;
}
A(const A& a) //拷贝构造
{
cout << "A(const A& a)" << endl;
}
~A() //析构
{
cout << "~A()" << endl;
}
private:
int _i = 1;
int _b = 1;
};
A* p1 = new A;
A* p2 = new A(2, 2);
A* p3 = new A[3]; //开数组
数组的话,多大就调用多少次 ,但是这是建立在有默认构造函数的基础上,如果没有默认构造函数,像下面这样。
A(int a1, int a2 = 0) //现在不是默认构造函数
:_i(a1)
,_b(a2)
{
cout << "A(int a1 = 0, int a2 = 0)" << endl;
}
在没有默认构造函数的情况下,前面的p1和p3那种写法绝对不可以了。传一个参数和传两个都是可以的,像下面这样。
A* p1 = new A(1);
A* p2 = new A(2, 2);
但是数组怎么初始化?
有下面几种方式。
第一种方法用有名对象。
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} };
这是什么个写法?记不记得之前我们说过,单参数构造函数支持隐式类型转换,多参数也支持,就是用{}括起来。这里其实走的是类型转换。
多说一句,花括号{}括起来是初始化,如果用圆括号()括起来就是逗号表达式,如下
A* p5 = new A[3]{ (1,1), (2,2),(3,3) }; //逗号表达式
A* p5 = new A[3]{ {1,1}, {2,2},{3,3} }; //初始化
逗号表达式的结果调试看一下就知道了。
4.operator new与operator delete函数
new和delete是用户进行动态申请和释放的操作符,operator new和operator delete是系统提供的全局函数,new在底层调用operator new全局函数来申请空间,delete在底层通过operator delete全局函数来释放空间。
全局函数的实现在这里就不展示了,可以自己去搜一下源代码。operator new实际上也是通过malloc来申请空间的,如果malloc申请空间成功就直接返回,否则执行用户提供的空间不足措施,如果用户提供该措施,就继续申请,否则就抛异常。operator delete最终是通过free来释放空间的。
5.new和delete的实现原理
5.1 内置类型
如果申请的是内置类型的空间,new和malloc,delete和free基本类似,不同的地方就是:new/delete申请和释放的是单个元素的空间,new[]和delete[]申请和释放的是连续的空间,而new在申请空间失败时会抛异常,malloc会返回NULL。
5.2 自定义类型
new的原理
1.调用operator new函数申请空间。
2.在申请的空间上执行构造函数,完成对象的构造(初始化)。
//比如这句代码,我们转到反汇编看一下底层
A* p1 = new A(1);
可以看到调用的是operator new这个函数,接着调用了构造函数去初始化。
delete的原理
1.在空间上执行析构函数,完成对象中资源的清理工作。
2.调用operator delete函数释放对象的空间。
delete p1;
new T[N]的原理
1.调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对象空间的申请。
2.在申请的空间上执行N此构造函数。
A* p2 = new A[3];
然后就是调用多次构造函数,在这就不细看了。
delete[]的原理
1.在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理。
2.调用operator delete[]释放空间,实际在operator new[]中调用operator delete来释放空间。
5.3 扩展学习
有析构函数的类,在new一个对象出来时,会在起始位置头部多开辟4个字节,来记录自己后面要开多少字节。没有析构函数的类,编译器会做优化,不在头部多开辟空间。
比如说下面这个B类,没有写析构函数,按照内存对齐规则,大小为8个字节。
class B
{
private:
int _b1 = 1;
int _b2 = 2;
};
如果要new一个B类的数组出来,如下
B* pb = new B[10]; //数组元素个数为10
在内存中空间开辟如图
如果是有析构函数的类,比如说我们前面提到的A类,按照内存对齐,A类大小也是8个字节,A类开空间时就会多开4个字节。
A* pa = new A[10];
但是pa指向的位置不是从最前面指,而是跳过额外开辟的位置,指向用户所需大小的位置。
但是不是所有编译器都是这样,底层是很复杂的。
如果我们在释放空间的时候,像下面这样,pa就会出错,pb不会
delete pb; //正确写法是delete[] pb
delete pa; //正确写法是delete[] pa
所以要匹配使用,不要乱搞。
6.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在释放空间前会调用析构函数完成空间资源的清理释放。
本篇分享就到这里,拜拜~
标签:malloc,int,C++,空间,内存,operator,new,delete From: https://blog.csdn.net/2402_82757055/article/details/142501002