[C/C++]C++中的内存管理

Posted 2021-07-19 TT在长大

1.C++的内存管理

C/C++中程序内存区域划分如下图：

（32bit中堆大致有2G的空间。）

2. 动态内存管理方式

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

在C语言中我们通常使用 malloc/calloc/realloc 和 free 进行空间管理。

（malloc向内存申请一块连续可用的空间，并返回指向这块空间的指针。calloc为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0。realloc重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。free用来释放动态开辟的内存。）

2.2 C++中动态内存管理方式

C++完全兼容C语言中的内存管理方式，但仍有非常多的问题，所以C++提出了新的内存管理方式：new和delete操作符。使得程序可以在运行期间，根据实际需要，要求操作系统临时分配一片内存空间用于存放数据。此种内存分配是在程序运行中进行的，而不是在编译时就确定的，因此称为“动态内存分配”。

使用new和delete来申请和释放单个元素的空间，使用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自动使用析构函数，而malloc与free不调用构造函数和析构函数。

class Test
{
public:
    Test()
        : _data(0)
    {
        cout<<"Test():"<<this<<endl;
    }
    ~Test()
    {
        cout<<"~Test():"<<this<<endl;
    }
private:
    int _data;
};
void Test2()
{
    // 申请单个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;
}

3.operator new与operator delete函数

3.1 operator new与operator delete函数

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

operator new

（1）只分配所要求的空间，不调用相关对象的构造函数。当无法满足所要求分配的空间时，则
        ->如果有new_handler，则调用new_handler，否则
        ->如果没要求不抛出异常（以nothrow参数表达），则执行bad_alloc异常，否则
        ->返回0
（2）可以被重载
（3）重载时，返回类型必须声明为void*
（4）重载时，第一个参数类型必须为表达要求分配空间的大小（字节），类型为size_t
（5）重载时，可以带其它参数

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

3.2 operator new与operator delete的类专属重载

下面进行演示：

/*针对链表的节点ListNode通过重载类专属
 operator new/ operator delete，
实现链表节点使用内存池申请和释放内存。*/

struct ListNode
{
    ListNode* _next;
    ListNode* _prev;
    int _data;
    void* operator new(size_t n)
    {
        void* p = nullptr;
        p = allocator<ListNode>().allocate(1);
        cout << "memory pool allocate" << endl;
        return p;
    }
    void operator delete(void* p)
    {
        allocator<ListNode>().deallocate((ListNode*)p, 1);
        cout << "memory pool deallocate" << endl;
    }
};

class List
{
public:
    List()
    {
        _head = new ListNode;
        _head->_next = _head;
        _head->_prev = _head;
    }
    ~List()
    {
        ListNode* cur = _head->_next;
        while (cur != _head)
        {
            ListNode* next = cur->_next;
            delete cur;
            cur = next;
        }

         delete _head;
        _head = nullptr;
    }
private:
    ListNode* _head;
};

int main()
{
    List l;
    return 0;
}

4.new和delete的实现原理

4.1内置类型

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

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

5. 定位new表达式

一般的new运算符负责在heap堆中找到一个足以能够满足要求的内存块。

new运算符还有另一种变体：定位new运算符（placement new），它能够让程序员指定要使用的位置。既将new运算符用于提供了的地址。

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

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

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

6.内存泄漏

6.1内存泄漏概念，内存泄漏的危害

内存泄漏（Memory Leak）是指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏缺陷具有隐蔽性、积累性的特征，比其他内存非法访问错误更难检测。因为内存泄漏的产生原因是内存块未被释放，属于遗漏型缺陷而不是过错型缺陷。此外，内存泄漏通常不会直接产生可观察的错误症状，而是逐渐积累，降低系统整体性能，极端的情况下可能使系统崩溃。

下面给出一些例子：

void MemoryLeaks()
{
    // 1.内存申请了忘记释放
    int* p1 = (int*)malloc(sizeof(int));
    int* p2 = new int;

    // 2.异常安全问题
    int* p3 = new int[10];
    Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
    delete[] p3;
}

6.2 内存泄漏分类

一般主要是两方面的内存泄漏：

堆内存泄漏(Heap leak)：堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
系统资源泄漏：指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

6.3 预防

1. 良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。

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

3. 使用内存泄漏工具检测。

一般解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。

 

最后希望大家多多指正。