【C++】C/C++内存管理

╰+攻爆jí腚メ 2024-03-27 17:00 14阅读 0赞

#### 文章目录 ####

*   *  1. C/C++内存分布
     *  2. C语言当中的动态内存管理
     *  3. C++ 内存管理方式
     *   *  3.1 new/delete操作内置类型
         *  3.2 new和delete操作自定义类型
     *  4. operator new 和operator delete 函数
     *  5. new和delete的实现原理
     *   *  5.1 内置类型
         *  5.2 自定义类型
     *  6. 定位new表达式(placement-new)
     *  7. 常见面试题
     *   *  7.1 malloc/free 和 new/delete区别

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

我们先来看看下面这段代码：

int globalVar = 1;
    static int staticGlobalVar = 1;
    void Test()
    {
        
    	static int staticVar = 1;
    	int localVar = 1;
    	int num1[10] = {
         1, 2, 3, 4 };
    	char char2[] = "abcd";
    	const char* pChar3 = "abcd";
    	int* ptr1 = (int*)malloc(sizeof(int) * 4);
    	int* ptr2 = (int*)calloc(4, sizeof(int));
    	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
    	free(ptr1);
    	free(ptr3);
    }

`globalVar`在哪里：数据段（静态区） `staticGlobalVar`在哪里：数据段（静态区）

`staticVar`在哪里：数据段（静态区） `localVar`在哪里：栈

`num1`在哪里：栈

全局变量和静态变量都是存在**数据段（静态区）**

`char2`在哪里： 栈 `*char2`在哪里：栈

`pChar3`在哪里： 栈 `*pChar3`在哪里：代码段（常量区）

`ptr1`在哪里：栈 `*ptr1`在哪里：堆

![e62acbfaefb1472bba05993325b8623d.png][]

`sizeof(num1)` = 40

`sizeof(char2)` = 5 `strlen(char2)`= 4

`sizeof(pChar3)` = 4/8 `strlen(pChar3)`= 4

`sizeof(ptr1)` = 4

`sizeof` 和`strlen`的区别：

![image-20230213183137240][]

说明：

1.  **栈**又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的
2.  **内存映射段**是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信
3.  **堆**用于程序运行时动态内存分配，堆是向上增长的
4.  **数据段**存储全局数据和静态数据
5.  **代码段**–可执行的代码只读常量

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

[文章][Link 1]

### 3. C++ 内存管理方式 ###

C语言的内存管理方式在C++当中可以继续使用，但是有些地方用起来比较麻烦，因此C++提出了自己的内存管理方式：**通过new和delete操作符进行动态内存管理**

#### 3.1 new/delete操作内置类型 ####

void Test()
    {
        
    	// 动态申请一个int类型的空间
    	int* ptr4 = new int;
    
    	// 动态申请一个int类型的空间并初始化为10
    	int* ptr5 = new int(10);
    
    	// 动态申请10个int类型的空间
    	int* ptr6 = new int[3];
    	delete ptr4;
    	delete ptr5;
    	delete[] ptr6;
    }

注意：**申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new\[\]和delete\[\]**匹配起来使用

#### 3.2 new和delete操作自定义类型 ####

class A
    {
        
    public:
    	A(int a = 0)
    		: _a(a)
    	{
        
    		cout << "A():" << this << endl;
    	}
    	~A()
    	{
        
    		cout << "~A():" << this << endl;
    	}
    private:
    	int _a;
    };
    int main()
    {
        
    	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
    	//还会调用构造函数和析构函数
    	A* p1 = (A*)malloc(sizeof(A));
    	A* p2 = new A(1);
    	free(p1);
    	delete p2;
    	// 内置类型是几乎是一样的
    	int* p3 = (int*)malloc(sizeof(int)); // C
    	int* p4 = new int;
    	free(p3);
    	delete p4;
    	A* p5 = (A*)malloc(sizeof(A) * 10);
    	A* p6 = new A[10];
    	free(p5);
    	delete[] p6;
    	return 0;
    }

注意：**在申请自定义类型的空间的时候，new会调用构造函数，delete会调用析构函数，而malloc和free不会**

### 4. operator new 和operator delete 函数 ###

new和delete使用户进行**动态内存申请和释放的操作符**， operator new 和operator delete是系统提供的**全局函数**。new在底层调用operator new全局函数来申请空间，delete在底层调用operator delete 全局函数来释放空间

/*
    operator new：该函数实际通过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);
    }
    /*
    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;
    }
    /*
    free的实现
    */
    #define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道，`operator new` 实际也是通过`malloc`来申请空间，如果申请成功就直接返回。否则执行用户提供的空间不足的应对措施，如果用户提供该措施就继续执行，否则抛出异常。`operator delete`实际上是通过`free`来释放空间的

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

#### 5.1 内置类型 ####

如果申请的是内置类型的空间，new和malloc，delete和free基本相似，不同的地方是new/delete申请和释放的是单个元素的空间，new\[\]和delete\[\]申请和释放的是连续空间。而且new在申请失败的时候会抛出异常，而malloc返回NULL

#### 5.2 自定义类型 ####

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

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

定位new表达式是**在已分配的原始内存空间中调用构造函数初始化一个对象**

使用格式：

`new(place_address)type`或者`new (place_address)type (initializer-list)`

`place_address`必须是一个指针，`initializer-list`是类型的初始化列表

**使用场景**：

定位new表达式在实际当中一般是配合内存池来使用的。因为内存池分配的内存并没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调用构造函数进行初始化

class A
    {
    public:
    	A(int a = 0)
    		: _a(a)
    	{
    		cout << "A():" << this << endl;
    	}
    	~A()
    	{
    		cout << "~A():" << this << endl;
    	}
    private:
    	int _a;
    };
    // 定位new/replacement new
    int main()
    {
    	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
    	A* p1 = (A*)malloc(sizeof(A));
    	new(p1)A;  // 注意：如果A类的构造函数有参数时，此处需要传参
    	p1->~A();
    	free(p1);
    	A* p2 = (A*)operator new(sizeof(A));
    	new(p2)A(10);
    	p2->~A();
    	operator delete(p2);
    	return 0;
    }

### 7. 常见面试题 ###

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

它们的共同点：都是从堆上申请空间，并且需要手动释放。不同的地方：

1.  malloc/free是函数，而new/delete是操作符
2.  malloc申请的空间不会初始化，new可以初始化
3.  malloc申请空间的时候需要手动计算空间大小并传递，new只需要在后面加上空间的类型就可以了，如果是多个对象只需要\[\]当中指定个数就可以了
4.  malloc返回值为void\*必须强转，new不需要，因为后面跟的就是空间的类型
5.  malloc申请空间失败的时候返回NULL，，因此必须判空，new不需要，new需要捕获异常
6.  申请自定义类型的对象的时候，malloc只会开辟空间，不会调用构造函数，而new在申请空间后会调用构造函数完成对对象的初始化，delete在释放空间之前会调用析构函数完成空间当中资源的清理

[e62acbfaefb1472bba05993325b8623d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/97eaaea3f58a4cbe8d99dc695abb5cb0.png
[image-20230213183137240]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8fe35673b8d84f8ba8f557dc50eaf669.png
[Link 1]: https://blog.csdn.net/qq_63474430/article/details/126999822