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

淡淡的烟草味﹌ 2022-10-07 00:58 128阅读 0赞

### 目录 ###

*  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++的内存分布 #

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center]

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

## 2.1 C语言管理方式 ##

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxNzUyMA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/adb3eb3780de4f2ebe16489c52fd6d05.png
[C]: https://blog.csdn.net/weixin_43717520/article/details/116047251