C/C++ 内存管理

最新推荐文章于 2024-11-11 17:04:07 发布

ღ星ღ

最新推荐文章于 2024-11-11 17:04:07 发布

阅读量686

点赞数 19

分类专栏： C++ 文章标签： jvm

本文链接：https://blog.csdn.net/weixin_63219391/article/details/137155077

版权

C++ 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1、C/C++内存分布

首先我们来了解在一个程序中，代码主要存储在哪些地方；

1.栈：又叫堆栈，其中一般存储非静态局部变量、函数参数、返回值等，栈的增长是向下的。

2.内存映射段：是高效的 I/O 映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享，共享内存，做进程间的通信。

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);
}
该段代码的在内存中的存储如图所示，static修饰的为静态变量，globalVal为全局变量，因此这两种都在数据段区域。malloc 、calloc、realloc开辟的动态空间一般都在堆上，指针，数据名称等都在栈中。

2 、C语言中动态内存管理方式：malloc、calloc、realloc、free

1.malloc、calloc、realloc三者的区别

malloc函数用于动态分配指定大小的内存块，接收一个单位，即要分配的内存块大小，返回一个指向分配内存的void类型指针，但是如果开辟内存失败则会返回NULL。
calloc函数和malloc一样都是用于动态分配的函数，但是与malloc不同的是，他有两个参数，其中第一个参数为要分配的元素数量，第二个参数为每个元素的大小，最后会将开辟好的内存初始化为零。开辟成功返回void类型指针，失败则返回NULL。
realloc函数是用于重新分配先前分配的内存块大小，通常在动态内存分配时，用于扩容。该函数有两个参数，第一个参数为先前分配的内存块的指针，第二个参数为新内存块的大小，分配成功返回指向新内存块的指针，失败则返回NULL；在使用realloc扩容时，会分为就地扩容和异地扩容两种。就地扩容：在原始内存块的基础上进行扩容，如果原始内存块后边有足够的连续空间，就会在原始内存块后边进行扩容，这样避免了数据的搬迁，比较高效。异地扩容：异地扩容会在其他地方开辟一个新空间，然后将旧空间数据拷贝的新空间中，这样就会导致额外的内存拷贝操作。

2. malloc 函数的实现原理

内存池管理：malloc() 函数会维护一个内存池，用于存储已分配和未分配的内存块。这个内存池可以是链表、树等数据结构，用于追踪哪些内存块是已分配的，哪些是可用的。

内存块分配：当调用 malloc() 时，它会搜索内存池以找到足够大的未分配内存块。这通常涉及到内存块的大小和对齐要求。如果找到了合适的内存块，它将被标记为已分配，并返回其地址给调用者。

内存块释放：当调用 free() 函数时，它将释放之前由 malloc() 分配的内存块。释放内存块的过程通常涉及将其标记为未分配，并合并相邻的未分配块以避免内存碎片化。

内存分配策略：malloc() 实现还需要考虑内存分配的效率和内存使用的最优化。常见的内存分配策略包括首次适配（First Fit）、最佳适配（Best Fit）和最差适配（Worst Fit）等。这些策略的选择会影响到内存池的管理效率和内存使用的紧凑程度。

内存对齐：在分配内存时，需要考虑内存对齐的问题。内存对齐是指内存分配时按照一定的字节边界进行分配，这样可以提高内存的访问效率。例如，有些平台要求某些数据类型必须在特定的内存地址上对齐，否则可能会导致性能问题或者错误。

错误处理：malloc() 函数可能会失败，返回 NULL。这种情况可能是由于内存池已满或者系统资源不足导致的。因此，malloc() 的实现需要进行适当的错误处理，以确保程序的稳定性。

3、C++内存管理方式

在C++中，提出了他自己的内存管理方式：通过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[ ]要匹配使用。

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来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的

5、new和delete的实现原理

5.1 内置类型

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

5.2 自定义类型

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来释放空间

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的区别

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

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

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

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

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

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

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

7.2 内存泄露

7.2.1 什么是内存泄漏，内存泄漏的危害

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

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

7.2.2 内存泄漏分类（了解）

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

堆内存泄漏(Heap leak）

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

系统资源泄漏

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

7.2.4如何避免内存泄漏

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

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

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

        4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。 总结一下: 内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。