C++篇 C/C++中的内存区域&new/delete

傷城~ 2023-06-11 03:29 3阅读 0赞

C++程序内存区域划分

C动态内存管理方式

C++动态内存管理方式 new  delete

1. new 和 delete用法

2. operator new与operator delete函数

3. new 和 delete 的实现原理

定位new表达式(placement-new)

小结

--------------------

# C++程序内存区域划分 ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70][] #

关于C/C++中的内存区域详解在另一篇博客写过, 这里就不再说了, [戳链接][Link 1]

# C动态内存管理方式 #

> 用**malloc/calloc/realloc和free**这四个函数来申请和释放堆上的内存  
> 我在另一篇博客中写过这四个函数, 这里就不多说了, [戳链接][Link 2]

# C++动态内存管理方式 new  delete #

> 为了兼容C语言, C++沿用C中的动态内存管理方式malloc/calloc/realloc和free, 同时C++又提出了自己的内存管理方式：通过**new**和**delete**操作符进行动态内存管理 .

### 1. new 和 delete用法 ###

> 1. new 后面紧跟类型, 申请和释放单个元素时用new 和delete , 多个使用 new \[\] 和delete \[\]  
> 2. 申请单个元素可以带括号初始化, 多个元素不能初始化  
> 3. 在用new为类或结构体等自定义申请内存时, **new会自动调用构造函数**, **delete会自动调用析构函数**(区别: mallloc/free都不会调用)  
> 4. 在用new为类或结构体等自定义申请内存时,  若这个自定义类型没有默认构造, 则不能用new \[\] 来申请多个空间(原因就是new和会调用构造函数).  
> 5. new在申请空间失败时会抛异常, malloc会返回NULL .

我们来直接看代码

int* ptr1 = new int;
    int* ptr2 = new int(10);
    int* ptr3 = new int[*ptr2];
    delete ptr1;
    delete ptr2;
    delete[] ptr3;

### 2. operator new与operator delete函数 ###

> 1. new和delete是用户进行动态内存申请和释放的操作符, C++将其直接设定成了关键字.
> 
> 2. operator new 和operator delete是系统提供的全局函数.  
> operator new 底层用malloc实现, operator delete 底层使用free来实现的是. 区别在于operator new中malloc申请成功直接返回内存首地址, 若申请失败则会执行申请失败的应对措施，如果我们提供了这个应对策略, 则继续尝试申请, 否则抛出异常
> 
> 3. new 和 delete 底层分别是由operator new和operator delete函数实现的
> 
> operator new 和operator delete有三种重载形式  
> (C++11)   
> (1)void\* operator new (std::size\_t size);     
> (2)void\* operator new (std::size\_t size, const std::nothrow\_t& nothrow\_value) noexcept;  
> (3)void\* operator new (std::size\_t size, void\* ptr) noexcept;
> 
> (1)void operator delete (void\* ptr) noexcept;  
> (2)void operator delete (void\* ptr, const std::nothrow\_t& nothrow\_constant) noexcept;  
> (3)void operator delete (void\* ptr, void\* voidptr2) noexcept;  
> 来看第一种怎么用,  
> void\* operator new(size\_t size)和void operator delete(void\* ptr)

#include<iostream>
    using namespace std;
    class T {
    	int m_a;
    public:
    	T() {
    		cout << "调用构造函数\n";
    	}
    	~T() {
    		cout << "调用析构函数\n";
    	}
    };
    void test() {
    	T* p1 = new T;
    	T* p2 = (T*)operator new(sizeof(T));
    	delete p1;
    	operator delete(p2);
    
    }
    int main() {
    	test();
    	system("pause");
    	return 0;
    }

![20191029114404237.png][]

我们可以看到构造和析构只调用了一遍, 分别是new和delete调用的, 而operator new 和operator delete不会调用

### 3. new 和 delete 的实现原理 ###

new delete ,  operator new   operator delete 和  malloc free 的 关系与区别图示

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 1][]

需要注意的是, 在用new 申请内置类型的空间时, 和operator new 并无区别, 因为内置类型并无构造函数, delete同理

由上图可见, 无特殊要求, 在C++中动态申请内存空间最好的方式使用操作符 new , 释放用 delete

我们再来详细看一下new为自定义类型申请空间时的操作

> 申请单个
> 
> new   
> 1. 调用operator new函数申请空间  
> 2. 在申请的空间上执行构造函数，完成对象的构造  
> delete  
> 1. 在空间上执行析构函数，完成对象中资源的清理工作  
> 2. 调用operator delete函数释放对象的空间

> 申请多个
> 
> new T\[N\]  
> 1. 调用operator new\[\]函数，在operator new\[\]中实际调用operator new函数完成N个对象空间的申请  
> 2. 在申请的空间上执行N次构造函数  
> delete\[\]  
> 1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理  
> 2. 调用operator delete\[\]释放空间，实际在operator delete\[\]中调用operator delete来释放空间

### 定位new表达式(placement-new) ###

> 内存池 : 在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是，使得内存分配效率得到提升。
> 
> 定位new表达式的使用, new(ptr) type ,即在new的后面加(), ()内传入内存池的地址, 再后面跟需要申请的类型
> 
> 需要注意的是, 定位表new达式使用的内存是内存池事先申请好的, 并不是new 申请的, 所以不需要delete, 只需要在内存池不再使用时释放掉这内存池就可以了
> 
> 来看下面的例子 :

#include<iostream>
    #include<string>
    using namespace std;
    
    void test() {
    	int* MemPool = (int*)malloc(1024);
    	int* ptr[10];
    	int poffset = 0;
    	cout << "内存池地址:" << (int)MemPool << endl;
    	for (int i = 0; i < 10; ++i, ++poffset) {
    		ptr[i] = new(MemPool + poffset) int;
    		*(ptr[i]) = i + 1;
    	}
    	cout << "sizeof(int) = " << sizeof(int) << endl;
    	for (int i = 0; i < 10; ++i) {
    		cout << *ptr[i] << " 的地址是: " << (int)ptr[i] << endl;
    	}
    	free MemPool;
    }
    
    int main() {
    	test();
    	system("pause");
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 2][]

可以看到, 所申请的10个int型数据的空间依次都存储在事先申请的内存池中, 这就很好的提高了效率(不用每次都去申请空间), 还避免了堆区内存碎片化的问题 (假如我们不是用内存池的话. 申请的这10个int数据, 它们在堆区内存是随机的, 堆区被这10个数据分割成了11块, 那么如果申请的不止10个, 是更多呢,  分割后的内存区域可能就比较小, 就不能再很好的利用, 甚至不能使用, 只能白白浪费, 也就是会加剧内存泄漏问题)

###  小结 ###

> 1. malloc / free 和new / delete 的异同?  
> 同 : 都是在堆区动态申请内存  
> 异 : (最主要2点)  
> 1. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，new在申请失败时会进行异常处理, 所以new需要捕获异常  
> 2.在给自定义类型申请空间时new和delete分别会调用构造函数和析构函数, 而malloc和free不会  
> 其他区别 :  
> 1. malloc/free是函数和new/delete是操作符  
> 2. malloc申请的空间不会初始化，new可以初始化  
> 3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可  
> 4. new/delete比malloc和free的效率稍微低点，因为new/delete的底层封装了operator new/operator delete, 而operator new operator delete底层又封装了malloc/free

相关应用 :[ C++实现一个只能在堆(栈)上生成对象的类][C]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70]: /images/20230531/948f3402792e44759c4603c7190435e6.png
[Link 1]: https://blog.csdn.net/qq_41071068/article/details/90758502
[Link 2]: https://blog.csdn.net/qq_41071068/article/details/90741413
[20191029114404237.png]: /images/20230531/d6d7748bac3b4c7889ae18e4663b7fff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 1]: /images/20230531/99e67fcd63654975adbc3790ae84c723.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 2]: /images/20230531/a9dd81a7a58f4a2ebda585b8be2ee683.png
[C]: https://blog.csdn.net/qq_41071068/article/details/102696312