C++--C/C++的内存管理--具体的内存分布--C++中动态内存管理--operator new/operator delete函数--具体封装的原理--内存池思想涉及--new的定位表达式-区分

朱雀 2022-11-10 03:47 30阅读 0赞

### C/C++的内存管理 ###

*  1.内存分布
 *  2.C中的动态内存管理
 *   *  malloc/calloc/realloc和free
 *  3.C++中的动态内存管理
 *   *  1)new/delete内置类型
     *  2)new/delete自定义类型
 *  4.operator new和operator delete函数
 *   *  1)基础
     *  2)使用方法
 *  5.封装operator new/operator delete
 *   *  1)内置类型
     *  2)自定义类型
 *  6.内存池思想涉及
 *   *  概念及原理
     *  代码实现及理解
 *  7.定位new的表达式
 *  8.相关面试题
 *   *  malloc/free和new/delete的区别

# 1.内存分布 #

在我们平时写的代码中,其实随随便便写的一个函数,在它的内部,每一行的代码都有可能储存在不同的位置,我们要主要理解他们是如何进行存放的.先来一个简单的代码来举例:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][20210316110103919.png]

# 2.C中的动态内存管理 #

## malloc/calloc/realloc和free ##

关于之前在C中我们已经很详细的讲解过了动态内存管理,在这里的我只用涉及到一个知识点,然后附上在C中的动态内存管理的链接:[点击此处][Link 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 1]

# 3.C++中的动态内存管理 #

对于C++中的new和delete的使用,我们分下面两种情况来进行讲解

## 1)new/delete内置类型 ##

内置类型就是相当于在一个函数的内部来进行执行,其执行方法和动态内存管理的是大体一致的,下面来具体实现:

//1.光进行申请
    
    int* p1=new int;	//光进行空间的申请
    
    delete p1;		//释放
    
    //2.申请+初始化
    
    int* p2=int(10);	//对空间进行申请,并将其初始化为10
    
    delete p2;		//将对应的空间进行释放
    
    //3.申请连续的空间
    
    int* arr=new int[10]	//申请10个连续的空间
    
    delete [] arr;		//对于连续的空间进行释放

其基本思路和动态内存的是一致的,主要理解构建框架就可以了.多运用.

## 2)new/delete自定义类型 ##

对于自定义类型就相当于对一个类进行调用的方式来申请空间和进行释放,**他也可以是除了类之外的任何类型**

**对于这种类型,我们首先先写一个简单的类,并且把其中的构造函数和析构函数模拟出来,然后在外部进行调用来实现空间的申请**

class a{ 
    public:
    	a(){ 
    		cout<<"a()"<<endl;
    	}
    	~a(){ 
    		cout<<"~a()"<<endl;
    	}
    private:
    	int _a=10;	
    };

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

# 4.operator new和operator delete函数 #

## 1)基础 ##

对于我们在上面讲到的关于new和delete两个函数,**其实都是通过调用operator delete和operator new两个函数进行实现的**,都是调用了最底层的这两个函数.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 3]

## 2)使用方法 ##

**operator new:malloc +异常**:其实就是进行了封装的方式再加上**抛出异常返回空值**

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

# 5.封装operator new/operator delete #

我们在上面已经详细的讲了关于**new和delete**的**使用原理**,其实就是运用了封装的方法进行的,在这里我们就是对**封装代码**的一个诠释,让我们可以更好地理解封装后的**operator new**和**operator delete**这两个函数.

## 1)内置类型 ##

**对内置类型的一个实现过程**:  
1.new: operator–>malloc

int* ptr=new int;

2.delete: operator delete–>free+抛出异常

delete ptr;

3.new\[ \]: operator new \[ \]–>operator -->malloc (直接释放)

int* ptr2=new int[];

4.delete \[ \]: operator delete \[ \]–>operator delete -->free (直接释放)

delete []ptr2;

## 2)自定义类型 ##

**对于自定义类型的实现过程:**  
1.new: operator new–>malloc–>构造

a* pa =new a;

2.delete: 析构 -->operator delete–>free

delete pa;

3.连续–在空间申请好的时候,直接执行n次构造

a* pa2=new a[10];

4.delete \[\]: 会执行一个n次的析构

delete []pa2;

# 6.内存池思想涉及 #

## 概念及原理 ##

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

## 代码实现及理解 ##

我在下面写了一个关于表的代码,在里面创建了两个外部函数,采用了内存池的方法,在执行下面的test()函数的时候,会看出来内部到底调用了那个函数,我们可以通过运行结果看出来:

struct listnode{ 
    public:
    
    	//在类的内部进行定义的时候,如果加了对应的返回值,则可以确定为外部函数
    	void* operator new(size_t n){ 
    		
    		cout << "operator new" << endl;
    		//采用内存池的方式
    		cout << "memory pool" << endl;
    		allocator<listnode>alloc;
    		return alloc.allocate(1);		//一个元素的大小
    	
    	}
    
    	void operator delete(void* ptr){ 
    		
    		cout << "operator delete" << endl;
    		allocator<listnode>alloc;
    		alloc.deallocate((listnode*)ptr, 1);
    		cout << "memory pool deallocate" << endl;
    
    	}
    
    	listnode(int data = 1)	//空间的初始化
    		:_data(data)
    	{ 
    		
    		cout << "listnode(int)" << endl;
    	}
    
    	~listnode(){ 
    		
    		cout << "~listnode()" << endl;
    	}
    private:
    	int _data=0;
    	listnode* _next = nullptr;
    	
    };
    
    void test(){ 
    
    	listnode* node = new listnode;		//创建
    
    	cout << "----------" << endl;		//分割线
    
    	delete node;		//释放
    }

**代码运行结果讲解:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 6]

# 7.定位new的表达式 #

这个表达式的主作用是:**对已经分配的原始内存空间进行初始化的操作**,一般来搭配内存池进行使用

**写一个简单的类,定义出构造函数和析构函数,并且申请出空间,然后再执行其操作**

**new定位表达式: new(指针)类型(参数列表)**

class a{ 
    
    public:
    	a(int a)
    		:_a(a)
    	{ 
    		cout << "a(int)" << endl;
    	}
    	~a(){ 
    		cout << "~a()" << endl;
    	}
    private:
    	int _a;
    };
    
    void test(){ 
    
    	a* pa = (a*)malloc(sizeof(a));
    	//初始化已有的空间
    	
    	//new定位表达式: new(指针)类型(参数列表)
    	new (pa)a(10);
    
    	pa->~a();	//在释放前将内部的资源全部清理掉,然后再进行空间的释放,不然容易会资源泄露
    	
    	free(pa);
    
    }

# 8.相关面试题 #

## malloc/free和new/delete的区别 ##

**共同点**:都是在堆上进行申请的,且需要我们进行手动的释放

**不同点:**  
1.malloc和free是**函数**,new和delete是**操作符**

2.malloc申请的空间**不会进行初始化**,而new会

3.malloc申请空间时,需要**手动**计算出大小,而new时则**不需要**

4.malloc的返回值为void\* ,且需要进行**强转**,new不需要**只要跟上空间的类型即可**

5.在malloc申请空间失败的时候**返回空**,我们在使用的时候则**需要进行判空**,而在new中**会抛出异常**,我们则需要**捕获异常**

6.在申请自定义空间的时候,malloc/free**只会开辟空间**,而对于new/delete来说,new时会调用**构造函数进行初始化**,在delete时会先调用**析构函数对其空间进行清理**,**再进行空间的释放.**

今天的这些就是对于C++ 利用new和delete包括内存池可以对C++中的内存能起到更加搞笑的作用,更好的来理解,这篇博客涉及到的内容有点多,大家仔细看,每句话都是有意义的,一起加油,多敲代码!!!

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70]: /images/20221023/2ae637c3fb41437e87bf963faafacc77.png
[20210316110103919.png]: /images/20221023/4ffa0bf1154d48d6bfe27569a636856e.png
[Link 1]: https://blog.csdn.net/weixin_46554582/article/details/113096738
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 1]: /images/20221023/fac97f08a4f24c7ead06804f98d3e451.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 2]: /images/20221023/d35b825831f440c2a40895f82d42a1d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 3]: /images/20221023/0ad18c8eaa5742e38f24d96d7e947c06.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 4]: /images/20221023/bb723182cba14ea9a3a67e86b5a3aef0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 5]: /images/20221023/3f0f5720702a490e9b02cc6a255cc35a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjU1NDU4Mg_size_16_color_FFFFFF_t_70 6]: /images/20221023/423a391a77394861803ebb904b7e11fb.png