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

Posted 2021-06-29 哦哦呵呵

目录

• 1. C/C++的内存分布
• 2. C语言与C++内存管理方式
• • 2.1 C语言管理方式
  • 2.2 C++内存管理方式
• 3 使用方法
• • 2.3.1 申请单个空间
  • 2.3.1 申请连续的空间
  • 2.3.2 申请4g的空间
• 4 注意申请和释放操作符要匹配使用
• • 4.1 对于内置类型
  • 4.2 对于自定义类型
• 5. new和delete的实现原理
• • 5.1 new T 和 delete T 实现原理
  • • 5.1.1 T 是自定义类型
• 6. new T[n] 和delete[] T 的实现原理
• 7. 定位new表达式
• • 7.1 概述
  • 7.2 使用
• 8. malloc/free 和 new/delete的区别

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

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

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

2.1 C语言管理方式

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

2.2 C++内存管理方式

  C语言中的内存管理方式在C++中仍然可以继续使用，但有些时候使用起来较为麻烦，所以引入了新的操作符进行内存管理
  new和delete进行内存管理。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 是内置类型

原理与malloc与free相同，直接进行申请或者释放

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再释放空间前会调用析构函数完成空间中资源的清理