【C++】动态内存管理

​内存区域的划分

        因为我们在程序中需要存储一些数据,如:

• 局部数据

• 静态数据和全局数据

• 常量数据

• 动态申请数据

        所以在C/C++中,内存区域相应的被划分成了如下5个部分:​编辑

​编辑

        【说明】

1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。

2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）

3. 堆用于程序运行时动态内存分配，堆是可以上增长的。

4. 数据段--存储全局数据和静态数据。

5.  代码段--可执行的代码/只读常量。

        了解了这些之后,我们再来通过一个经典练习题深入理解一下内存区域的划分,如下代码:

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);

}

1. 选择题：
选项 : A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)

globalVar在哪里？____

staticGlobalVar在哪里？____
staticVar在哪里？____

localVar在哪里？____
num1 在哪里？____

char2在哪里？____

* char2在哪里？___
pChar3在哪里？____

* pChar3在哪里？____
ptr1在哪里？____

* ptr1在哪里？____

2. 填空题：
sizeof(num1) = ____;
sizeof(char2) = ____;

strlen(char2) = ____;
sizeof(pChar3) = ____;

strlen(pChar3) = ____;
sizeof(ptr1) = ____;

3. sizeof 和 strlen 区别？

        我们来逐一分析一下:

1.选择题:

• globalVar是一个全局变量,显然是存放在静态区的,所以选择C;

• staticGlobalVar是一个静态的全局变量,它也存放在静态区,所以选择C;

• staticVar是一个静态的局部变量,它也存放在静态区,所以选择C;

• localVar是一个局部变量,它存放在栈中,所以选择A;

• num1代表一个局部整型数组,所以选择A;

• char2是一个局部指针变量,它指向一个字符数组,所以选择A;

• *char2是一个拷贝常量字符串得到的字符数组,所以选择A;

• pChar3是一个const修饰的指针变量,它指向一个常量字符串,所以选择A(注意,const修饰的变量是常变量,只是因为const修饰而具有了常属性,该变量并不会因为const修饰而改变存放的位置);

• *pChar3是一个常量字符串,它存在于常量区,所以选择D;

• ptr1是一个局部指针变量,它指向动态开辟的一块空间,所以选择A;

• *ptr1是一块动态开辟的空间,它存在于堆中,所以选择B;

2.填空题:

• sizeof(num1) 计算的是数组num1的大小,它包含10个整形元素,因此大小是4*10=40;

• sizeof(char2) 计算的是数组char2的大小,它包含5个字符型元素(包括'\0'),因此大小是5;

• strlen(char2) 计算的是数组char2的字符长度,不包括'\0',因此大小是4;

• sizeof(pChar3) 计算的是指针pChar3的大小,一般为4/8个字节(由系统决定);

• strlen(pChar3)计算的是常量字符串"abcd"的长度,不包括'\0',因此大小是4;

• sizeof(ptr1) 计算的是指针ptr1的大小,一般为4/8个字节(由系统决定);

3.sizeof 和 strlen 区别？

        sizeof() 和 strlen() 在 C 语言中两个非常常用，它们都与计算内存大小有关，但是它们的作用是不同的。

        sizeof() 和 strlen() 的主要区别在于：

• sizeof() 是一个运算符，而 strlen() 是一个函数。

• sizeof() 计算的是变量或类型所占用的内存字节数，而 strlen() 计算的是字符串中字符的个数。

• sizeof() 可以用于任何类型的数据，而 strlen() 只能用于以空字符 '\0' 结尾的字符串。

• sizeof() 计算字符串的长度，包含末尾的 '\0'，strlen() 计算字符串的长度，不包含字符串末尾的 '\0'。

        sizeof() 函数是一个运算符而不是函数，用于计算一个类型或变量所占用的内存字节数。可以用它来获取任何类型的数据的字节数，包括基本数据类型、数组、结构体、共用体等等。

        strlen() 函数用于计算一个字符串的长度，即它所包含的字符个数（不包括字符串结尾的空字符 '\0'）。需要注意的是，strlen() 函数只能用于计算以空字符 '\0' 结尾的字符串的长度，如果字符串中没有空字符，则 strlen() 函数的行为是未定义的。

C++动态内存管理

        在C语言中,动态内存的管理是通过这几个函数来实现的:

• malloc() , 为大小为size字节的对象分配存储空间 , 此存储空间中的初始值不确定 . 若分配成功 , 则返回一个指向已分配的空间开头的指针 ; 若分配失败 , 则返回空指针 .

• calloc() , 为num个大小为size字节的对象分配存储空间 , 该空间内的所有位都会初始化为0 . 若分配成功 , 则返回一个指向已分配的空间开头的指针 ; 若分配失败 , 则返回空指针 .

• realloc() , 更改ptr指向的已分配空间的大小 , 重新分配为size大小 , 若分配成功 , 则返回一个指向已分配的空间开头的指针 ; 若分配失败 , 则返回空指针 .

• free() , 释放ptr指向的空间 , 让这部分空间能继续用于之后的动态分配 . 当ptr为空指针时 , 不执行任何操作 . 除此之外 , 当实际参数与之前通过malloc() , calloc() , realloc()返回的指针不一致时 , 或者ptr指向的空间已经通过调用free()或realloc()被释放时 , 则作未定义处理 .

更多详细有关C语言动态内存管理的知识可以移步:【C语言】内存的动态分配与释放

        在C++中,动态内存的管理是通过一对运算符来完成的:

• new,在动态内存中为对象分配空间并返回一个指向该对象的指针,我们可以选择对对象进行初始化;

• delete,接受一个动态对象的指针,销毁该对象,并释放与之关联的内存.

使用new动态分配和初始化对象

        在堆空间分配的内存是无名的,因此new无法为其分配的对象命名,而是返回一个指向该对象的指针:

int* pi = new int;//pi指向一个动态分配的,未初始化的无名对象

        此new关键字在堆空间构造一个int型对象,并返回指向该对象的指针.

        当我们想要构造多个对象时,我们只需要在类型后面加上:[个数],就可以了,如:

int* pia = new int[10];

        默认情况下,动态分配的对象是默认初始化的,这意味着内置类型或组合类型的对象的值将是未定义的,如果我们想要在动态分配时就直接将空间初始化,则需要使用传统的构造方式(使用圆括号),如:

int* p = new int(5); //p指向的对象的值为5

        当我们想要一次性初始化数组的多个对象时,我们则需要在[]后面使用{}来初始化,如:

int* ptr = new int[10]{ 1,2,3,4,5 };

        注意,当我们只将整形数组中的一部分内容初始化时,整形数组剩余的内容则会被系统默认初始化为0(不同类型的数组可能默认逻辑不同):​编辑

使用delete将动态内存归还给系统

        与new相对应的,为了防止内存耗尽,在动态内存使用完毕后,必须将其归还给系统.我们通过delete关键字(delete expression)来将动态内存归还给系统.

        delete关键字接受一个指针,指向我们想要释放的对象:

int *pi=new int;

delete pi; //pi必须指向一个动态分配的对象或是一个空指针

        此delete表达式执行两个动作:销毁给定的指针指向的对象pi ; 释放pi对应的内存.

        当我们要释放的是动态开辟的多个对象时,我们只需要在delete后面加上:[],就可以了,如:

int* pia = new int[10];

delete[] pia;

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

malloc/free和new/delete的区别

        malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：

• malloc和free是函数，new和delete是操作符

• malloc申请的空间不会初始化，new可以初始化

• malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可

• malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型

• malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常

• 申请自定义类型对象时，malloc/free只会开辟空间/释放空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

        对于最后一点,我们拿之前写过的Date类来验证一下:

​编辑

        除此之外,还需要注意的是,当我们使用new/delete来动态开辟/销毁类对象的数组时,new和delete会对数组中的每个类对象都进行构造/析构,如:

​编辑

operator new和operator delete函数

operator new和operator delete函数

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

        operator new和operator delete及free的部分源代码:

/*

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)

        new和malloc以及operator new的关系是:

        new的功能是开空间+调用构造函数,而开空间的这部分功能可以使用malloc来完成,但是malloc在设计时采用的报错方式是返回错误码,这和C++中的报错方式——抛异常不符,因此就使用malloc函数按照C++的报错方式专门封装了一个用来开空间的函数——operator new,由它来接替malloc函数完成开空间的任务.如下图:

​编辑

        同理,delete和free以及operator delete的关系与之相同,如下图:

​编辑

new和delete的实现原理

内置类型

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

自定义类型

• 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 (place_address) type或者new (place_address) type(initializer-list)


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

使用场景

        定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化.(主要是为了减少项目频繁的直接从堆上开辟/销毁空间,从而提高效率)​编辑
 

使用示例

// 定位new/replacement new

int main()

{

    // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行

    A* p1 = (A*)malloc(sizeof(A));

    new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参

    p1->~A();//注意,这里不调用析构函数的话,p1是不会自己调用析构函数的,因为p1是指针,是内置类型,不是自定义类型,只有自定义类型才会自动调用构造和析构函数

    free(p1);

    A* p2 = (A*)operator new(sizeof(A));

    new(p2)A(10);

    p2->~A();

    operator delete(p2);

    return 0;

}

内存泄漏

什么是内存泄漏

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

内存泄漏的危害

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

内存泄漏的分类

        C/C++程序中一般我们关心两种方面的内存泄漏：

堆内存泄漏(Heap leak)

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

系统资源泄漏

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

如何检测内存泄漏

        在vs下，可以使用windows操作系统提供的_CrtDumpMemoryLeaks() 函数进行简单检测，该函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息。

int main()

{

    int* p = new int[10];

    // 将该函数放在main函数之后，每次程序退出的时候就会检测是否存在内存泄漏

    _CrtDumpMemoryLeaks();

    return 0;

}

////////////////////////////////////////////////////////

// 程序退出后，在输出窗口中可以检测到泄漏了多少字节，但是没有具体的位置

Detected memory leaks!

Dumping objects ->

{79} normal block at 0x00EC5FB8, 40 bytes long.

Data: < > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD

Object dump complete.

        因此写代码时一定要小心，尤其是动态内存操作时，一定要记着释放。但有些情况下总是防不胜防，简单的可以采用上述方式快速定位下。如果工程比较大，内存泄漏位置比较多，不太好查时一般都是借助第三方内存泄漏检测工具处理的。

• 在linux下内存泄漏检测：linux下几款内存泄漏检测工具

• 在windows下使用第三方工具：VLD工具说明

• 其他工具：内存泄漏工具比较

如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。

2. 采用RAII思想或者智能指针来管理资源。

3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

总结一下:
        内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

结语

希望这篇关于 c++动态内存管理 的博客能对大家有所帮助,欢迎大佬们留言或私信与我交流.

学海漫浩浩,我亦苦作舟!关注我,大家一起学习,一起进步!

​