纯净、安全、绿色的下载网站

首页|软件分类|下载排行|最新软件|IT学院

当前位置:首页IT学院IT技术

C++入门之内存处理 C++入门之内存处理详解

捕获一只小肚皮   2021-11-18 我要评论
想了解C++入门之内存处理详解的相关内容吗捕获一只小肚皮在本文为您仔细讲解C++入门之内存处理的相关知识和一些Code实例欢迎阅读和指正我们先划重点:C++入门,C++内存处理下面大家一起来学习吧。

前言

兜兜转转,我们终于结束了C++中非常重要的一环**(类和对象),现在来到了C++中的内存管理章节.在此篇文章中,博主将会介绍内存的分布,不同于c的新型申请堆区空间方法,new,delete和C中的malloc等有什么不同.**

C/C++内存分布

在c和c++中,内存区大概分为这几个板块:栈区,内存映射段,堆区,数据段和代码段.

  • 栈区: 存放非静态局部变量,函数参数,函数返回值等,其优先使用高地址,并逐渐往下.
  • 内存映射段:高效的I/O映射方式用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存做进程间通信.由于博主还未更新到操作系统,这里不做过多介绍.
  • 堆区: 用于程序运行时进行动态内存分配(一般使用malloc),其优先使用低地址,逐渐往上.
  • 数据段:存储全局数据和静态变量.
  • 代码段:可执行的代码/只读常量.

理论千遍,不如用例子一现,大家往下看:

image-20211024195521282

在上图中,大家可以清晰的看到各种类型数据的存储区域,一目了然.

c语言中动态内存管理方式

我们在学习c语言时候,想要向堆区申请一块空间,只能通过malloc()函数,而且操作比较麻烦,需要计算申请空间的大小并且进行强制转换.

int* p1 = (int*) malloc(sizeof(int));
free(p1);
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
free(p3 );

我们可以清晰的看到,在c语言中申请一块堆区内存空间,操作有点繁琐,那么在C++语言中,是怎么申请一块堆区内存呢?

C++内存管理方式

在c++中,c语言的内存管理方式依然可以使用,但是有些地方仍然使用c中的方法进行申请就比较麻烦,因此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理.

那么什么时候使用c内存管理方式就会比较麻烦呢?比如下面:

class Stack
{
public:
	Stack(int* p,int n)
    {
        val = p;
        top = capacity = n;
    }
private:
    int* val;
    int top;
    int capacity;
};
int main()
{
    Stack* stack = (Stack*)malloc(sizeof(Stack));
    //然后现在我们想要进行初始化,发现好像不能操作了(因为私有成员外部无法访问),这就会比较麻烦,因此提出了new和delete的操作
    return 0;
}

new和delete操作基础类型

①开辟单个元素基本语法: type* name = new type(content);

①释放空间语法: delete name;

其中type是开辟的元素类型,name是变量名,content是想要赋的值,例如:

int* a = new int(10);         //开辟一个整型空间,并且初始化为10;
char* s = new char('s');      //开辟一个字符空间,并且初始化为's';
delete a;
delete s;                     //释放a和s

②开辟数组基本语法: type* name = new type[n]

②删除数组基本语法:delete[] name;

其中type是开辟的元素类型,name是数组名,n是空间数量,例如:

int* num = new int[10];         //开辟10个int类型的空间
char* str = new char[10];        //开辟10个char类型的空间
delete[] num;
delete[] str;    //释放num和str;

注意点:在c语言中malloc,realloc,calloc等是函数,在c++中,new和delete是操作符.

new和delete操作自定义类型

使用语法和上面的自定义类型几乎一样,只是初始化位置有点差别,语法:type* name = new type(s1,s2,s3...);

其中type是自定义的类型,s1,s2,s3等是自定义类型中构造函数的对应参数.例子:

class Test
{
public:
    Test(int a,int b,int c)
    {
        _a = a;
        _b = b;
        _c = c;
    }
private:
    int _a;
    int _b;
    int _c;
};
int main()
{
    Test* t = new Test(1,2,3);  //根据构造函数参数列表写对应参数.
    delete t;
}

基于malloc开辟并初始化的自定义类型

有人可能会有点好奇,说,我就是要用malloc开辟自定义类型,但是我还想初始化,这么进行操作?答案是,可以的,需要搭配new

语法 new(type*) type(s1,s2,s3...)

什么意思呢?我们仍然按照上面的Test类举例:

Test* t = (Test*) malloc(sizeof(Test));
new(t)Test(1,2,3);    //这样就可以初始化了.

new和delete底层实现原理

在讲解他们的底层实现原理之前我们先介绍一下两个全局函数,分别是operator newoperator delete.

operator new和operator delete

大家看到上面的形式可能会误认为是对new和delete进行了重载,实际并不是,只是这两个函数就叫做这名字而已.

我们在学习C语言时候,还记得是当开辟空间时候需要进行检查是否成功吗?而operator new其实和malloc一模一样,只是它对空间开辟失败后做出的反应是抛出异常,而c语言中,我们是手动判断,然后停止.下面是operator new的代码:

void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	// try to allocate size bytes
	void* p;
	while ((p = malloc(size)) == 0)              //如果开辟成功就不会进入循环,并且可以清晰
		if (_callnewh(size) == 0)
		{
			// report no memory
			// 如果申请内存失败了这里会抛出bad_alloc 类型异常
			static const std::bad_alloc nomem;
			_RAISE(nomem);
		}
	return (p);
}

同理,operator delete不过也就是free,下面是它的代码:

void operator delete(void* pUserData)
{
	_CrtMemBlockHeader* pHead;
	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
	if (pUserData == NULL)
		return;
	_mlock(_HEAP_LOCK); /* block other threads */
	__TRY
		/* get a pointer to memory block header */
		pHead = pHdr(pUserData);
	/* verify block type */
	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
	_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK); /* release other threads */
	__END_TRY_FINALLY
		return;
}

总结:operator new其实就是对malloc的封装,operator delete 就是堆free的封装.

new的底层实现

new的实现其实是进一步对malloc的封装,因为new的操作可以分为下面两件事:

  • 调用operator new进行开辟空间.
  • 如果开辟的空间是自定义类型,new再调用其构造函数.

所以说,new的内部其实就是有构造函数和operator new封装而成.

delete的底层实现

同样的道理,delete不过就是对free的进一步封装,因为delete的操作可以分为下面两件事:

  • 如果new开辟的空间是自定义类型,则首先调用其析构函数释放其内部资源.
  • 然后再调用operator delete,进行释放new所开辟出来的空间.

注意了,这里可能有人不明白自定义类型先释放内部,然后销毁外部空间啥意思,博主这里画图介绍,不过大家先看一下下面的一个类:

class Stack
{
public:
	Stack()
		:num(new int[10]),
		top(0),capacity(10)
	{}
	~Stack()
	{
		delete[] num;
		top = capacity = 0;
	}
private:
	int* num;
	int top;
	int capacity;
};
int main()
{
    Stack stack;
    delete stack;
    return 0;
}

如果我们定义一个该对象,那么其空间分布如下:

image-20211025172631194

如果delete不先调用析构函数,那么释放了stack对象后,在堆区里面的num将会继续存在,导致内存泄露.

new[]的底层实现

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

2.在申请的空间上执行N次构造函数

delete[]的原理

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

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

总结

本篇文章就到这里了希望能够给你带来帮助也希望您能够多多关注的更多内容!


相关文章

猜您喜欢

  • redis存储Session redis缓存存储Session原理机制

    想了解redis缓存存储Session原理机制的相关内容吗程序媛张小妍在本文为您仔细讲解redis存储Session的相关知识和一些Code实例欢迎阅读和指正我们先划重点:redis缓存机制,redis存储Session原理机制下面大家一起来学习吧。..
  • MySQL 索引最左匹配 MySQL数据库索引的最左匹配原则

    想了解MySQL数据库索引的最左匹配原则的相关内容吗风幕浦在本文为您仔细讲解MySQL 索引最左匹配 的相关知识和一些Code实例欢迎阅读和指正我们先划重点:MySQL,索引最左匹配,MySQL索引最左原则下面大家一起来学习吧。..

网友评论

Copyright 2020 www.tdogsoftware.com 【零度软件园】 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 点此查看联系方式