[C++] C++中的内存管理机制

1. C/C++的内存分布

内存分区所存内容
由操作系统自动分配释放,主要存储局部变量、函数参数等
由程序员进行管理,由程序员进行分配管理,动态空间的开辟和管理
数据段由系统进行分配释放,存储全局数据与静态数据
代码段由系统进行分配释放,存储常量与可执行代码

在这里插入图片描述

2. C语言与C++内存管理方式

2.1 C语言管理方式

C语言内存管理已经在此篇文章中详细介绍 C语言动态内存管理
故不再进行赘述。

2.2 C++内存管理方式

  C语言中的内存管理方式在C++中仍然可以继续使用,但有些时候使用起来较为麻烦,所以引入了新的操作符进行内存管理
  newdelete进行内存管理。new用于申请内存,delete用于释放内存。

3 使用方法

2.3.1 申请单个空间

范式:new 类型申请空间 , delete 变量名 释放空间。

  申请完空间之后不需要进行判空操作。

int main()
{
	int* p = new int;
	int* p2 = new int(100); // 申请一块内存空间并初始为100

	delete p;
	delete p2;

	return 0;

2.3.1 申请连续的空间

范式:new 类型[] 申请连续的地址空间,delete[] 释放连续空间

int main()
{
	int* p1 = new int[100];
	int* p2 = new int[10]{ 1, 2, 3, 4, 5, 6, 7 };   // 申请连续空间并初始化

	delete[] p1;
	delete[] p2;

	return 0;
}

2.3.2 申请4g的空间

因为new运算符可以指定大小,所以使用字符型直接申请4个g的空间,但必须要放在64为环境下申请,因为32最大只能支持4g

int main()
{
	void* p = new char[0xffffffff];

	delete[] [;

	return 0;
}

4 注意申请和释放操作符要匹配使用

匹配关系:

  • malloc --> free
  • new --> delete
  • new[] --> deletep[]

如果不匹配使用:

4.1 对于内置类型

int main()
{
	int* p1 = new int[100];
	int* p2 = new int;
	int* p3 = (int*)malloc(sizeof(int));

	free(p1);
	delete p2;
	delete p3;

	return 0;
}

程序运行结果正确,没有发生程序崩溃的现象,说明系统内置类型,如果不匹配使用操作符,对程序结果没有影响。

4.2 对于自定义类型

class Test
{
public:
	Test(int _a, const char* _str)
	{
		str = (char*)malloc(strlen(str) * sizeof(char));
		a = _a;
		strcpy(str, _str);
	}

	~Test()
	{
		free(str);
	}

private:
	int a;
	char* str;
};

int main()
{
	Test* t = new Test(1, "123");	// 会调用类中的构造函数
	free(t);	// 不会调用类的析构函数

	Test* t1 = (Test*)malloc(sizeof(Test));	 // 不会调用类的构造函数
	delete t1;	// 会调用类的析构函数

	return 0;
}

如果使用malloc申请对象,不会调用类的构造函数,只是申请了一个大小空间与类相同的空间,但是使用delete会调用类的析构函数,没有调用构造函数则没有申请资源,调用析构函数直接释放资源则程序必然会出错。

使用new申请 free释放同理,会造成内存呢泄露

5. new和delete的实现原理

问题提出 为什么不写析构函数,混用new-delete[] 与new[]-delete不会造成内存泄露?

5.1 new T 和 delete T 实现原理

1. new T 和 delete T
   T 是内置类型

原理与mallocfree相同,直接进行申请或者释放

5.1.1 T 是自定义类型

1. new操作符
1.1 申请空间
  调用operator new申请空间,底层实现其实是通过对malloc函数的重新封装。

/*
该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间失败,
尝试执行空间不足应对措施,如果改应对措施用户设置了,则继续申请,否则抛异常。
*/
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);
}

malloc申请空间是,如果堆内存空间足够,则返回申请空间的首地址,如果内存不足,则执行下方if语句中的处理,对内存进行操作,整理内存,再次进行内存的申请,直到内存空间申请成功,或者申请不成功抛出异常。

1.2 调用构造函数,完成对空间中内容的初始化
  在上述的申请空间完成后,只是完成了空间的申请,并没有完成对应空间的内容的初始化,所以要调用构造函数对空间中内容进行自定义的初始化操作。

2. delete操作符
2.1 调用析构函数,释放对象内部资源
  如果没有释放对象内部的资源,直接释放对象,则会造成内存的泄露,所以必须要先释放对象中的内部资源,再销毁对象

2.2 再调用operator delete释放该对象的资源

/*
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;
}

看上面代码可以看出,delete内部还是利用free进行了释放空间的操作。

6. new T[n] 和delete[] T 的实现原理

1. new T[n]
  该方法与上述new实现原理相同

1.申请空间 调用上方operator new函数进行申请空间
2.调用n次构造函数,对空间进行初始化

2. delete[] T
  该方法与上述delete实现原理相同

1.调用n次析构函数清理对象内部资源,释放与构造顺序相反
2.释放对象空间

7. 定位new表达式

7.1 概述

  该方法与上述new实现原理相同当我们使用malloc申请空间时,每次只申请一小块空间,空间也是需要使用结构体进行管理的,所以空间,多次释放小空间会进行内存的浪费
  该方法与上述new实现原理相同所以我们可以申请一块较大的空间,没事如果要使用空间,就从这块大空间中取出一块空间进行使用,但是这块空间本没有类型,就用到了定位new表达式进行初始化,使其使用的空间类型变为指定类型。

7.2 使用

class Test
{
public:
	Test()
		: _data(0)
	{
		cout<<"Test():"<<this<<endl;
	}
	
	~Test()
	{
		cout<<"~Test():"<<this<<endl;
	}

private:
	int _data;
};
void Test()
{
	// pt现在指向的只不过是与Test对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行
	Test* pt = (Test*)malloc(sizeof(Test));
	
	// 将Test类型大小的空间类型通过调用构造函数初始化为该类型
	new(pt) Test; // 注意:如果Test类的构造函数有参数时,此处需要传参
}

8. malloc/free 和 new/delete的区别

共同点

都是从堆上分配,并且需要用户手动释放

不同点

  • malloc和free是函数,new和delete是操作符
  • malloc申请的空间不会初始化,new可以初始化
  • malloc申请空间时需要计算申请多大空间,new只需要再其后跟上空间类型即可
  • malloc的返回值为void*,再使用时必须强转。new不需要,因为申请时已经指定了类型
  • malloc申请空间失败时,返回值为NULL,因此需要判空。new会进行异常捕获。
  • 申请自定义类型时,malloc和free只会开辟或释放空间,不会调用构造与析构函数。而new再申请空间后会调用构造函数完成对象的初始化,delete再释放空间前会调用析构函数完成空间中资源的清理
  • 4
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值