首页 > 系统相关 >【C++】内存管理:内存分布、new/delete

【C++】内存管理:内存分布、new/delete

时间:2024-09-28 15:51:25浏览次数:10  
标签:malloc int C++ 空间 内存 operator new delete

        本篇主要介绍一下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

相关文章

  • C++ Practical-2 day2 运算符重载之时钟类++运算符
    系列文章目录点击直达——文章总目录文章目录系列文章目录C++Practical-2day2运算符重载之时钟类++运算符Overview1.时间类重载后缀`++`运算符来递增时间1.1.解释1.2.注意事项2.如何确保时间递增操作在多线程环境中是线程安全的?关于作者C++Practical-2day......
  • 10.C++程序中的循环语句
    C++中提供了三种循环语句(for循环,while循环以及do-while循环)来使程序员可以更方便地对数据进行迭代操作。if语句for语句的格式为:for(初始化语句;循环条件;迭代语句){代码块}for循环首先会执行初始化语句,主要是用于初始化循环变量和其它变量,然后判断条件是否为真,如果为真,则执......
  • 【C++】set与map
    一、什么是set、mapset和map是专门用来搜索的数据结构,是一种适合查找的容器,set和map的底层是二叉搜索树。*setset的声明:set<T>set中的相同元素只能存在一个。multiset(与set用法相同)可以存放多个相同元素。*mapmap的声明:map<T1,T2>map存储的匀速是pairmap中的与T1......
  • 【C++篇】迈入新世界的大门——初识C++(下篇)
    文章目录   前言   引用        引用的概念和定义        引用的特性        引用的使用        const引用        指针和引用的关系  inline         ......
  • 《 C++ 修炼全景指南:十三 》为什么你的代码不够快?全面掌控 unordered_set 和 unordere
    摘要本文深入探讨了C++标准库中的两大无序容器——unordered_set和unordered_map,从底层实现、核心操作、性能优化、实际应用等多个方面进行了全面分析。首先,文章介绍了这两种容器的基本概念,说明了它们基于哈希表实现的特点,尤其是在查找、插入和删除操作上具备常数时间......
  • 06 内存地址示例 重点
    ################################回顾示例1v1=[1,2,3]#开僻内存空间v2=[1,2,3]#开僻内存空间示例二v1=[1,2,3]#v2、v3都指向变量v1内存地址v2=v1v3=v1v1.append(999)#此时v2/v3都会发生变化,因v1把内存地址中的值进行修改了示例三v......
  • C++设计模式
    C++设计模式提供了一些常见的问题和解决方案,帮助我们写出更清晰、更高效、更容易维护的代码。1.单例模式:就像整形诊所里有一个特别的规定,全世界只能有一个人拥有某款独一无二的鼻子,其他人都不能复制。(确保一个类只有一个实例,并提供一个全局访问点。)classSingleton{priva......
  • C C++ 强制类型转换
    强制类型转换概念在C语言中,强制类型转换(强转)是一种将一个数据类型的值转换为另一个数据类型的操作。它允许程序员显式地改变表达式的数据类型。语法强转的语法形式为:(目标类型)表达式。例如,(int)3.14会将浮点数3.14强制转换为整数类型,结果为3。作用不同类型数据运算时......
  • 【Qt】编写第一个Qt程序 && 对象树 && 内存泄漏问题探讨
    编写第一个Qt程序1.使用图形化界面生成2.使用代码生成3.对象树3.1什么是对象树3.2验证对象树4.解决编码问题1.使用图形化界面生成创建好一个项目后,我们可以点击widget.ui进入图形化界面设计,可以直接通过拖拽的方式进行添加。通过拖拽的方式进行设计此......
  • 【项目综合】高并发内存池
    目录一、项目背景1)mini版的tcmalloc2)内存池是什么3)C/C++的malloc和new4)所用技术栈和项目环境二、实现定长内存池1)基本框架2)申请内存块3)释放内存块4)细节优化和性能测试 三、高并发内存池的整体框架四、实现threadcache申请内存1)基本框架2)哈希桶中的映射......