C++：智能指针-阿里云开发者社区

内存泄漏

内存泄漏是指程序在动态分配内存后，忘记或无法释放已经不再使用的内存，从而导致系统内存资源被逐渐耗尽的问题。这种情况下，即使程序本身并没有出现逻辑错误，也会因为内存泄漏而导致程序运行时间越来越长，甚至最终崩溃。

案例分析:

下面是一个典型的 C++ 内存泄漏案例：

while (true)
{
    int* p = new int(10);

    // 这里忘记释放内存,导致内存泄漏
}

在这个程序中，我们在一个无限循环中不断分配新的内存块。然而，我们忘记在循环体内释放这些内存块，导致程序运行时内存占用会越来越大，直到最终耗尽系统内存，程序崩溃。

这种情况下，即使程序本身没有逻辑错误，也会因为内存泄漏而导致严重的问题。

内存泄漏的危害:

系统内存资源被逐渐耗尽：内存泄漏会导致程序运行时内存占用越来越大，直到最终耗尽系统内存。这会严重影响程序的性能和稳定性。
程序可能会崩溃：内存耗尽后，程序会尝试访问非法内存地址，从而导致程序崩溃。
资源浪费：即使程序没有崩溃，内存泄漏也会导致大量内存资源被无谓地占用，造成资源浪费。

内存泄漏是 C++ 程序中一个非常常见的问题，如果不能及时发现并修复，会对程序的性能、稳定性和安全性造成严重影响。

RAII机制就是一种自动管理资源的机制，其可以帮助程序员自动释放资源，来避免内存泄漏，C++中，智能指针就是基于RAII产生的。

RAII

RAII (Resource Acquisition Is Initialization) 是 C++ 中一种非常重要的内存管理机制，它可以帮助我们有效地管理资源，避免内存泄漏等问题。

RAII 的核心思想是:

将资源的分配和释放绑定在对象的生命周期上。

在对象构造时获取资源，在对象析构时释放资源。

以下示例就是一个基本的RAII：

template <class T>
class smartPtr
{
public:
    smartPtr(T* ptr)
        :_ptr(ptr)
    {}

    ~smartPtr()
    {
        delete _ptr;
    }

private:
    T* _ptr;
};

int main()
{
    smartPtr<int> ptr1 = new int(5);
    smartPtr<double> ptr2 = new double(3.14);
    smartPtr<vector<int>> ptr3 = new vector<int>(10);

    return 0;
}

在上述示例中，smartPtr 类负责管理资源的获取和释放。在 main 函数中,我们创建了三个 smartPtr 对象 ptr1、 ptr2、 ptr3。

当这些对象进入作用域时，构造函数会被调用，将smatrPtr的_ptr成员初始化为对应动态内存的指针。

当三个对象离开作用域时，析构函数会被自动调用，自动delete _ptr释放资源。

通过 RAII 机制，我们可以确保资源一定会被正确释放，避免了手动释放资源时忘记的问题。这种做法也使得代码更加简洁易读,并且可以实现异常安全性。

这样做的好处是:

确保资源一定会被正确释放，避免了手动释放资源时忘记的问题。
资源的获取和释放过程被封装在对象的构造和析构函数中，使得代码更加简洁易读。
可以利用 RAII 机制实现异常安全性，即使程序抛出异常，资源也能被正确释放。

而以上案例，就是C++智能指针最根本的原理，C++一共提供了四种智能指针：auto_ptr、unique_ptr、shared_ptr、weak_ptr。

智能指针

讲解这四种智能指针之前，我们先看看我刚刚案例中的smartPtr存在的问题：

template <class T>
class smartPtr
{
public:
    smartPtr(T* ptr)
        :_ptr(ptr)
    {}

    ~smartPtr()
    {
        delete _ptr;
    }

private:
    T* _ptr;
};

int main()
{
    smartPtr<int> ptr1 = new int(5);
    smartPtr<int> ptr2 = ptr1;

    return 0;
}

在main函数中，先构造了ptr1，指向一个int类型的动态内存。随后拿ptr1拷贝构造出了ptr2，此时ptr1和ptr2都指向这个int的动态内存。那么此时就要面临一个问题：当ptr1和ptr2出了作用域，那么两个对象都会调用析构函数，导致同一块内存被delete两次！这会直接导致进程崩溃，C++的智能指针需要解决这个问题。

另外的，智能指针本质上是一个类，不自带*，->等操作，所以要对操作符进行重载：

T operator*()
{
    return *_ptr;
}

T* operator->()
{
    return _ptr;
}

*，->等操作本质都是在对_ptr做操作，至于为什么要这样操作，可见博客[C++：迭代器的封装思想]。

接下来我们正式讲解C++自带的各种智能指针：

C++的智能指针，包含在<memory>头文件中

讲解以下四个智能指针时，默认包含了<memory>头文件。

auto_ptr

auto_ptr是C++标准中，最早出现的智能指针，属于C++98。

构造函数：

auto_ptr自带一个通过指针来进行初始化的构造函数，但是其被explicit修饰，这说明不允许进行类型转换：

auto_ptr<int> ptr1(new int(5));//正确
auto_ptr<int> ptr2 = new int(10);//错误

auto_ptr只允许通过第一种方式，直接构造，第二种方式的本质是类型转换，从int*转为auto_ptr<int>，只要有对应类型的构造函数那么C++就可以支持这个类型转换，但是如果构造函数被explicit修饰，这个类型转换功能就会被禁止，而auto_ptr就被禁止了。

其实，C++的四种智能指针，都不允许通过原生指针的类型转化来构造，也就是四种智能指针都只能通过小括号来初始化。

不过拷贝构造是允许的：

auto_ptr<int> ptr1(new int(5));

auto_ptr<int> ptr3(ptr1);
auto_ptr<int> ptr2 = ptr1;

后两种拷贝方式，都是正确的，因为拷贝构造没有被explicit修饰。

提到拷贝，我们刚讲到RAII中，如果多个类指向同一块空间，会导致资源重复释放的问题，那么auto_ptr是如何解决的呢？

当auto_ptr发生拷贝，原先的auto_ptr会变成空指针

为了方便观察，我们需要得知指针指向的地址：auto_ptr可以get接口看到内部存储的地址。

示例：

auto_ptr<int> ptr1(new int(5));
auto_ptr<int> ptr2 = ptr1;

cout << ptr1.get() << endl;
cout << ptr2.get() << endl;

输出结果：

0000000000000000
00000294B7187000

可以看到，经过拷贝后ptr1内部的值变为了0000000000000000，也就是空指针，原先指向动态内存的指针交给了ptr2。

如果是delete，delete空指针的结果是啥也不干，因此可以保证内存的安全。

不过这种解决方案过于简单粗暴了，后续在C++11又出了三个智能指针，以更加优秀的方式来处理这个问题。

unique_ptr

unique_ptr以一种非常简单粗暴的方式来处理智能指针的拷贝问题：

unique_ptr不允许拷贝

这确实很简单粗暴，从源头上解决问题，如果你确定你不需要对指针进行拷贝，可以考虑使用unique_ptr。

相比于auto_ptr，unique_ptr还有一个优化，那就是下标访问opertaor[]。

示例：

auto_ptr<int> ptr1(new int[10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
cout << ptr1[5] << endl;//错误

这个auto_ptr指向了一个通过new[]开辟的数组，原生指针是支持下标访问的，但是auto_ptr不支持，以上代码的第二行是错误的。

看到unique_ptr：

unique_ptr<int> ptr1(new int[10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
cout << ptr1[5] << endl;//错误

对于这种情况，unique_ptr也会报错，如果想要unique_ptr支持下标访问，要用更加特殊的语法：

unique_ptr<int[]> ptr1(new int[10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
cout << ptr1[5] << endl;//正确

如果指向的动态内存是数组的形式，一次性开辟的，模板参数要写为type[]的形式，来告诉unique_ptr该指针维护的动态内存，是以数组的形式开辟的。以上示例中，模板参数为int[]，那么此时就可以通过下标来访问这个动态内存了。

shared_ptr

shared_ptr是对拷贝处理的最好的一个智能指针，其机制也比较复杂，实际中更常用这一种智能指针。

shared_ptr通过引用计数来处理多个指针指向同一块内存的问题

对于同一块内存，有多少个shared_ptr指向该内存，那么count就是多少：

上图中，动态内存被三个shared_ptr指向，那么count = 3，现在ptr3离开作用域：

ptr3离开作用域后，count = 2，说明此时还有两个指针指向这个动态内存，那么ptr3的析构函数不会释放掉动态内存！

当ptr2离开作用域：

此时count = 1，整个动态内存只有一个ptr1指向，只要ptr1离开作用域，那么count = 0，此时ptr1的析构函数就会把动态内存释放掉。

也就是说shared_ptr通过记录有几个指针指向动态内存，来决定析构的时候是否释放内存，将动态内存的释放交给最后一个shared_ptr来完成，既能确保每一个shared_ptr都是有效的，又可以确保资源不会被重复释放。

要注意的是：不是所有shared_ptr都共用一个count，对于每一块动态内存，都有独立的count，互不影响。

上图中，ptr1、ptr2、ptr3指向A，ptr4和ptr5指向B。

此时ptr1、ptr2、ptr3共用一个count，ptr4和ptr5共用一个count。

与unique_ptr一样，shared_ptr也可以支持下标访问：

shared_ptr<int[]> ptr1(new int[10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
cout << ptr1[3] << endl;

循环引用

shared_ptr会存在一个循环引用的问题。

现在我们有如下链表节点：

class ListNode
{
public:
    ListNode(int val)
        : _prev(nullptr)
        , _next(nullptr)
        , _val(val)
    {}

    ListNode* _prev;
    ListNode* _next;
    int _val;
};

int main()
{
    ListNode* l1 = new ListNode(5);
    ListNode* l2 = new ListNode(10);

    l1->_next = l2;
    l2->_prev = l1;

    delete l1;
    delete l2;
    
    return 0;
}

以上代码中，l1是l2的后一个节点，因此l1->_next = l2，l2->_prev = l1，最后程序结束前，delete掉两个节点，这段代码是没问题的。

现在我们把以上代码中的原生指针，改为shared_ptr：

class ListNode
{
public:
    ListNode(int val)
        : _prev(nullptr)
        , _next(nullptr)
        , _val(val)
    {}

    shared_ptr<ListNode> _prev;
    shared_ptr<ListNode> _next;
    int _val;
};

int main()
{
    shared_ptr<ListNode> l1(new ListNode(5));
    shared_ptr<ListNode> l2(new ListNode(10));

    l1->_next = l2;
    l2->_prev = l1;
    
    return 0;
}

请问这串代码有问题吗？

其实在以上代码中，就已经造成了内存泄漏问题，这就是典型的循环引用问题，我来解析一下：

一开始，通过两个shared_ptr指向了两个ListNode的动态内存：

此时两块内存都分别只被一个shared_ptr指向，count = 1。

随后执行l1->_next = l2，l2->_prev = l1：

此时ListNode内部的指针互相指向，由于ListNode内部的指针也是shared_ptr，count都变成了2。

随后l2离开作用域，此时count--：

由于l1->_next依然指向橙色的内存，此时count = 1，不会释放内存。

随后l1离开作用域，count--：

由于l2->_prev指向绿色区域（l2其实已经不存在了），count = 1，此时不释放内存。

现在陷入一个死循环：如果绿色区域要被释放，那么橙色的_prev就要先释放，但是橙色的_prev要释放，那绿色的_next要先释放，造成一个死循环，导致内存永远无法释放，内存泄漏。这就是循环引用问题。

如果在类的内部使用这种相互指向的shared_ptr，就很容易发生循环引用的问题。

这个问题在于，_prev和_next这两个成员存在的意义，在于互相访问资源，我们并不需要_prev和_next来完成资源的释放，所以_prev和_next完全没必要用shared_ptr，用一般的指针即可：

class ListNode
{
public:
    ListNode(int val)
        : _prev(nullptr)
        , _next(nullptr)
        , _val(val)
    {}

    ListNode* _prev;
    ListNode* _next;
    int _val;
};

但是现在存在一个问题：

l1->_next = l2;
l2->_prev = l1;

这两天语句是错误的，因为l2的类型是shared_ptr<ListNode>，而l1->_next的类型是ListNode*，shared_ptr的类型转换是被禁止的，所以只能通过get接口：

l1->_next = l2.get();
l2->_prev = l1.get();

这样未免太不简洁，此时就需要我们的最后一个智能指针weak_ptr出场了。

weak_ptr

weak_ptr是一种不参与资源管理的智能指针，其只存在三种构造函数：

无参默认构造，此时weak_ptr初始化为空指针
拷贝构造，拷贝其它weak_ptr
通过shared_ptr初始化，此时shared_ptr和weak_ptr指向同一块内存

当shared_ptr和weak_ptr指向同一块内存的时候，weak_ptr不会增加引用计数！

weak_ptr离开作用域的时候，不会释放自己指向的资源，其只负责访问资源。特点在于可以通过shared_ptr初始化。

因此刚刚的循环引用可以被优化为：

class ListNode
{
public:
    ListNode(int val)
        : _val(val)
    {}

    weak_ptr<ListNode> _prev;
    weak_ptr<ListNode> _next;
    int _val;
};

要注意的是，weak_ptr不支持原生指针初始化，哪怕是nullptr也不可以，因此在ListNode的初始化列表中，删掉了_next和_prev的初始化。

现在以下代码就完全合法了：

shared_ptr<ListNode> l1(new ListNode(5));
shared_ptr<ListNode> l2(new ListNode(10));

l1->_next = l2;
l2->_prev = l1;

weak_ptr可以通过shared_ptr初始化，因此可以直接将shared_ptr赋值给weak_ptr，又由于weak_ptr不参与计数，最后只要l1，l2离开作用域，空间就会被正常释放。

deleter

对于智能指针，有时候需要用特殊的方式来对资源进行释放，比如文件指针：

shared_ptr<FILE> fp(fopen("test.txt", "w"));

对于指针fp，不能简单地delete pf，而是通过fclose(pf)，此时我们就要用到自定义删除器deleter了。

对于shared_ptr和unique_ptr，两者的deleter语法不太相同，此处分开讲解：

shared_ptr

shared_ptr的语法为：

shared_ptr<T> p(new T, deleter_function);

其中, deleter_function是一个满足删除器要求的可调用对象，包括函数指针，仿函数，lambda三种。

比如通过lambda来完成文件的fclose：

shared_ptr<FILE> fp(fopen("test.txt", "w"), [](FILE* ptr) { fclose(ptr); });

通过仿函数：

struct deleteFile
{
    void operator()(FILE* ptr)
    {
        fclose(ptr);
    }
};

int main()
{
    shared_ptr<FILE> fp(fopen("test.txt", "w"), deleteFile());

    return 0;
}

也就是说，对于shared_ptr，只需要把删除器的可调用对象，直接作为第二个参数传入即可。

unique_ptr

unique_ptr的删除器语法比较别扭，要求在模板参数中传入可调用对象的类型。

unique_ptr<T, 可调用对象类型> p(new T, 可调用对象);

同样的，可调用对象支持函数指针，仿函数，lambda三种。

以刚刚的关闭文件为例：

使用函数指针：

void deleteFunc(FILE* ptr)
{
    fclose(ptr);
}

int main()
{
    unique_ptr<FILE, void(*)(FILE*)> fp2(fopen("test.txt", "w"), deleteFunc);

    return 0;
}

该函数指针的类型为void(*)(FILE*)，作为unique_ptr的第二个模板参数。

使用仿函数：

struct deleteFile
{
    void operator()(FILE* ptr)
    {
        fclose(ptr);
    }
};

int main()
{
    unique_ptr<FILE, deleteFile> fp(fopen("test.txt", "w"), deleteFile());

    return 0;
}

仿函数的类型是deleteFile，即类名，作为unique_ptr的第二个模板参数。

使用lambda表达式：

auto expression = [](FILE* ptr) { fclose(ptr); };
unique_ptr<FILE, decltype(expression)> fp(fopen("test.txt", "w"), expression);

这里, expression是一个lambda表达式，由于lambda的类型是随机的，只能通过decltype(expression)来检测类型，作为unique_ptr的第二个模板参数。

C++：智能指针

内存泄漏

RAII

智能指针

auto_ptr

unique_ptr

shared_ptr

循环引用

weak_ptr

deleter

shared_ptr

unique_ptr

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C++：智能指针

内存泄漏

RAII

智能指针

auto_ptr

unique_ptr

shared_ptr

循环引用

weak_ptr

deleter

shared_ptr

unique_ptr

热门文章

最新文章

相关课程

相关电子书