C&C++内存管理

女爷i 2023-03-03 15:27 25阅读 0赞

## 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";
        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在哪里？**c**  
staticGlobalVar在哪里？c  
staticVar在哪里？**c**  
localVar在哪里？**a**  
num1 在哪里？**a**  
char2在哪里？**a**  
\*char2在哪里？*a*\_  
pChar3在哪里？**a**  
\*pChar3在哪里？**d**  
ptr1在哪里？**a**  
\*ptr1在哪里？**b**

选项: A.栈 B.堆 C.数据段 D.代码段  
根据上面的题，可以得出c&c++程序的内存划分如下：  
![c&c++内存分布][c_c]  
【说明】

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

## C语言中动态内存管理方式 ##

**malloc/calloc/realloc和free**

void Test () { 
        int* p1 = (int*) malloc(sizeof(int));
            free(p1);
            
            int* p2 = (int*)calloc(4, sizeof (int));
            int* p3 = (int*)realloc(p2, sizeof(int)*10);
            
            // 这里不需要free(p2)；
            free(p3 ); 
    }

malloc/calloc/realloc三者都是分配内存，都是stdlib.h库里的函数，它们之间的区别为：

> （1）：malloc函数：原型为void \*malloc(unsigned int num\_bytes)；

num\_byte为要申请的空间大小，需要我们手动的去计算；

> （2）：calloc函数： 原型为void \*calloc(size\_t n, size\_t size)；

比malloc函数多一个参数，并不需要人为的计算空间的大小，比如如果要申请20个int类型空间，使用int \*p = (int \*)calloc(20, sizeof(int)）,这样就省去了人为空间计算的麻烦。但这并不是他们之间最重要的区别，malloc申请后空间的值是随机的，并没有进行初始化，而calloc在申请后，对空间逐一进行初始化，并设置值为0;

**那么既然有了calloc函数，为什么还需要malloc函数呢？**

> 任何事物都有两面性，有好的一面，必然存在不好的地方。对于这两个函数来说。问题就在于效率。calloc函数由于给每一个空间都要初始化值，那必然效率malloc要低，并且现实世界，很多情况的空间申请是不需要初始值的。

> (3）：realloc函数：原型为extern void \*realloc(void \*mem\_address, unsigned int newsize);

用于改变原内存的大小，新的大小可大可小（如果新的大小大于原内存大小，则新分配部分不会被初始化；如果新的大小小于原内存大小，可能会导致数据丢失  
过程：先判断当前的指针是否有足够的连续空间，如果有，扩大mem\_address指向的地址，并且将mem\_address返回，如果空间不够，先按照newsize指定的大小分配空间，将原有数据从头到尾拷贝到新分配的内存区域，而后释放原来mem\_address所指内存区域（注意：原来指针是自动释放，不需要使用free），同时返回新分配的内存区域的首地址。即重新分配存储器块的地址。

## c++内存管理方式 ##

**new/delete操作符（并非函数）**

**new和delete操作内置类型：**

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

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

**new和delete操作自定义类型:**

class Test { 
    public:
        Test()
             : _data(0)
        { }
     
        ~Test()    
        { }
    private:
        int _data;
    };
    void Test1() { 
        // 申请单个Test类型的空间
        Test* p1 = (Test*)malloc(sizeof(Test));
        free(p1);        
        // 申请10个Test类型的空间 
        Test* p2 = (Test*)malloc(sizoef(Test) * 10);
        free(p2);
     }
     void Test2() { 
         // 申请单个Test类型的对象 
         Test* p1 = new Test;// 
         delete p1;        
         // 申请10个Test类型的对象 
         Test* p2 = new Test[10];    
         delete[] p2;
    }

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

### operator new与operator delete函数 ###

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

operator new 函数：该函数实际上是通过调用malloc函数来申请空间的，当malloc函数申请空间成功时直接返回，申请空间失败时，尝试执行空间不足应对措施，如果该应对措施用户设置了，则继续申请，否则抛异常；  
operator delete 函数：最终是通过free函数来释放空间的，并不会有异常；

## new和delete实现原理 ##

### 对内置类型 ###

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

### 对自定义类型 ###

**new的原理：**

> 1.  调用operator new函数申请空间
> 2.  在申请的空间上执行构造函数，完成对象的构造

*即先申请空间，再调用构造函数；*

**delete的原理：**

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

*即先调用析构函数清理资源，再释放空间；*

**new \[N\] 的原理：**

> 1.  调用operator new\[\]函数，在operator new\[\]中实际调用operator new函数完成N个对象空间的申请
> 2.  在申请的空间上执行N次构造函数

**delete \[\] 的原理：**

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

## 定位new表达式 ##

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

**使用格式：**  
new (place\_address) type或者new (place\_address) type(initializer-list)  
place\_address必须是一个指针，initializer-list是类型的初始化列表

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

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));
          new(pt) Test;  // 注意：如果Test类的构造函数有参数时，此处需要传参
    }

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

**共同点：**  
都是从堆上申请的空间，并且都需要用户手动释放；

**不同点：**

> 1：malloc和free是函数，new和delete是操作符；  
> 2：malloc申请空间不会初始化，new可以初始化；  
> 3：malloc申请空间时，需要手动计算大小并传递，new只需要在后面跟上空间类型即可；  
> 4：malloc的返回值为 void\*，使用时必须强转，new不需要，因为new后面跟的是空间类型；  
> 5：malloc申请空间失败时，返回的是NULL,所以必须判空，new不需要，但是要捕获异常；  
> 6：申请自定义类型对象的空间时，malloc/free只会开辟和释放空间，不会调用构造函数和析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前调用析构函数清理资源；

## 内存泄漏 ##

### 什么是内存泄漏 ###

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不 是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而 造成了内存的浪费。

### 内存泄漏的危害 ###

长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会 导致响应越来越慢，最终卡死

### 内存泄露的分类 ###

**堆内存泄漏(Heap leak）**：堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存， 用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那 么以后这部分空间将无法再被使用，就会产生Heap Leak

**系统资源泄露**：指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统 资源的浪费，严重可导致系统效能减少，系统执行不稳定。

[c_c]: /images/20230208/fde3a005733641bc8f0dcf37da76d6de.png