C++ 智能指针详解：RAII 思想与 shared_ptr 原理

总结一下智能指针的原理：

(1) RAII 特性
(2) 重载 operator 和 operator->，具有像指针一样的行为*。

2.2 auto_ptr

C++98 版本的库中就提供了 auto_ptr 的智能指针，auto_ptr 支持拷贝，但是拷贝时，管理权限转移，会造成被拷贝指针悬空。

使用方法如下：

struct Date {
    int _year;
    int _month;
    int _day;
    Date(int year = 1, int month = 1, int day = 1) : _year(year), _month(month), _day(day) {}
    ~Date() { std::cout << "~Date()" << std::endl; }
};

int main() {
    std::auto_ptr<Date> ap1(new Date);
    // 拷贝时，管理权限转移，被拷贝 (ap1) 指针悬空
    std::auto_ptr<Date> ap2(ap1);
    // 此时 ap1 为空指针了，访问直接报错！
    // ap1->_year++;
    return 0;
}

结论：auto_ptr 是一个失败设计，很多公司明确要求不能使用 auto_ptr。

2.3 unique_ptr

C++11 中开始提供更靠谱的 unique_ptr，unique_ptr 的实现原理：简单粗暴的防拷贝。

使用方法如下：

struct Date {
    int _year;
    int _month;
    int _day;
    Date(int year = 1, int month = 1, int day = 1) : _year(year), _month(month), _day(day) {}
    ~Date() { std::cout << "~Date()" << std::endl; }
};

int main() {
    std::unique_ptr<Date> up1(new Date);
    // 不支持拷贝
    // std::unique_ptr<Date> up2(up1);
    return 0;
}

三、shared_ptr(重点)

C++11 中开始提供更靠谱的并且支持拷贝的 shared_ptr。

3.1 shared_ptr 的原理及使用

shared_ptr 的原理：是通过引用计数的方式来实现多个 shared_ptr 对象之间共享资源。

原理实现的具体细节：

(1) shared_ptr 在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
(2) 在对象被销毁时 (也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
(3) 如果引用计数是 0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
(4) 如果不是 0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

使用方法如下：

struct Date {
    int _year;
    int _month;
    int _day;
    Date(int year = 1, int month = 1, int day = 1) : _year(year), _month(month), _day(day) {}
    ~Date() { std::cout << "~Date()" << std::endl; }
};

int main() {
    std::shared_ptr<Date> sp1(new Date);
    std::shared_ptr<Date> sp2(sp1);
    std::shared_ptr<Date> sp3(sp2);
    return 0;
}

3.2 shared_ptr 的模拟实现

1. 基本框架

namespace bit {
    template<class T>
    class shared_ptr {
    public:
        // 构造，拷贝等其他接口...
        T* get() const { return _ptr; }
        int use_count() const { return *_pcount; }
        // 重载运算符，模拟指针的行为
        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }
    private:
        T* _ptr;
        int* _pcount; // 引用计数
        std::function<void(T* ptr)> _del = [](T* ptr){ delete ptr; }; // function 的默认构造中没有可调用对象，不给缺省值会报错
    };
}

2. 引用计数的设计

每个资源都要配一个引用计数，是用来记录有多少个对象共同指向这块资源的。

不是每个对象都配一个计数，也不能直接使用 static 静态变量，这样所有对象都用一个计数了，显然不合理。

所以我们要在堆上开一块空间保存计数，用一个指针指向这个计数，当每次有对象指向同一块空间时，就可以找到这个指针指向的计数++，析构时计数--。每次构造的时候就出现新资源，所以要在构造的时候申请。

shared_ptr(T* ptr = nullptr) : _ptr(ptr), _pcount(new int(1)) {} // 每个资源给一个计数

3. 拷贝构造

把一个对象拷贝给另一个对象，说明这个对象的资源与另一个对象共享了，计数++。

// sp2(sp1)
shared_ptr(const shared_ptr<T>& sp) : _ptr(sp._ptr), _pcount(sp._pcount) {
    (*_pcount)++;
}

4. 析构函数

如果引用计数到 0，说明已经没有对象指向这块资源了，就要释放该资源。

void release() {
    if (--(*_pcount) == 0) {
        // delete _ptr;
        _del(_ptr);
        delete _pcount;
        _ptr = nullptr;
        _pcount = nullptr;
    }
}
~shared_ptr() { release(); }

5. 赋值拷贝

赋值拷贝是已经存在的两个对象之间。所以赋值时要注意那个对象原先资源的处理，原先的计数要先--。并且要注意避免自己给自己赋值。

// sp1 = sp3
shared_ptr<T>& operator=(shared_ptr<T>& sp) {
    // 避免自己给自己赋值。用资源的指针判断
    // 指向同一块资源就不白费赋值
    if (_ptr != sp._ptr) {
        release();
        _ptr = sp._ptr;
        _pcount = sp._pcount;
        (*_pcount)++;
    }
    return *this;
}

3.3 shared_ptr 的循环引用

循环引用问题是一个巨坑，出现时必然会导致内存泄漏问题。

struct ListNode {
    int _data;
    std::shared_ptr<ListNode> _next;
    std::shared_ptr<ListNode> _prev;
    ~ListNode() { std::cout << "~ListNode()" << std::endl; }
};

int main() {
    // 循环引用 -- 内存泄漏
    std::shared_ptr<ListNode> n1(new ListNode);
    std::shared_ptr<ListNode> n2(new ListNode);
    std::cout << n1.use_count() << std::endl;
    std::cout << n2.use_count() << std::endl;
    n1->_next = n2;
    n2->_prev = n1;
    std::cout << n1.use_count() << std::endl;
    std::cout << n2.use_count() << std::endl;
    return 0;
}

循环引用分析图解：

解决方案：在引用计数的场景下，把节点中的_prev 和_next 改成 weak_ptr 就可以了。
原理就是：weak_ptr 不支持管理资源，不支持 RAII。n1->_next = node2 和 n2->_prev = n1 时，weak_ptr 的_next 和_prev 不会增加 n1 和 n2 的引用计数。

使用 weak_ptr 要包含头文件：

#include <functional>

struct ListNode {
    int _data;
    std::weak_ptr<ListNode> _next;
    std::weak_ptr<ListNode> _prev;
    ~ListNode() { std::cout << "~ListNode()" << std::endl; }
};

在我们自己的 shared_ptr 中也进行简单的模拟实现：

template<class T>
class weak_ptr {
public:
    weak_ptr() {}
    // 不增加引用计数
    weak_ptr(const shared_ptr<T>& sp) : _ptr(sp.get()) {}
    weak_ptr<T>& operator=(const shared_ptr<T>& sp) {
        _ptr = sp.get();
        return *this;
    }
};

3.4 定制删除器

如果不是 new 出来的对象如何通过智能指针管理呢？？其实 shared_ptr 设计了一个删除器来解决这个问题。(ps：删除器这个问题我们了解一下)

仿函数的删除器

template <class T>
class DeleteArray {
public:
    void operator()(T* ptr) { delete[] ptr; }
};

class Fclose {
public:
    void operator()(FILE* ptr) {
        std::cout << "fclose:" << ptr << std::endl;
        fclose(ptr);
    }
};

int main() {
    std::shared_ptr<Date[]> sp4(new Date[5]);
    std::shared_ptr<FILE> sp5(fopen("test.cpp", "r"), Fclose());
    return 0;
}

但是每次写仿函数还是有些麻烦，所以可以在 shared_ptr 的类中进行实现：

// 定制删除器
template<class D>
shared_ptr(T* ptr, D del) : _ptr(ptr), _pcount(new int(1)), _del(del) {}

3.5 shared_ptr 实现的完整代码

shared_ptr.h

#pragma once
#include <functional>

namespace bit {
    template<class T>
    class shared_ptr {
    public:
        // RAII
        shared_ptr(T* ptr = nullptr) : _ptr(ptr), _pcount(new int(1)) {} // 每个资源给一个计数

        // 定制删除器
        template<class D>
        shared_ptr(T* ptr, D del) : _ptr(ptr), _pcount(new int(1)), _del(del) {}

        // sp2(sp1)
        shared_ptr(const shared_ptr<T>& sp) : _ptr(sp._ptr), _pcount(sp._pcount) {
            (*_pcount)++;
        }

        // sp1 = sp3
        shared_ptr<T>& operator=(shared_ptr<T>& sp) {
            // 避免自己给自己赋值。用资源的指针判断
            // 指向同一块资源就不白费赋值
            if (_ptr != sp._ptr) {
                release();
                _ptr = sp._ptr;
                _pcount = sp._pcount;
                (*_pcount)++;
            }
            return *this;
        }

        void release() {
            if (--(*_pcount) == 0) {
                // delete _ptr;
                _del(_ptr);
                delete _pcount;
                _ptr = nullptr;
                _pcount = nullptr;
            }
        }

        ~shared_ptr() { release(); }

        T* get() const { return _ptr; }
        int use_count() const { return *_pcount; }

        // 重载运算符，模拟指针的行为
        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }

    private:
        T* _ptr;
        int* _pcount; // 引用计数
        std::function<void(T* ptr)> _del = [](T* ptr){ delete ptr; }; // function 的默认构造中没有可调用对象，不给缺省值会报错
    };

    template<class T>
    class weak_ptr {
    public:
        weak_ptr() {}
        weak_ptr(const shared_ptr<T>& sp) : _ptr(sp.get()) {}
        weak_ptr<T>& operator=(const shared_ptr<T>& sp) {
            _ptr = sp.get();
            return *this;
        }
    private:
        T* _ptr = nullptr;
    };
}

Test.cpp

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include "shared_ptr.h"

struct Date {
    int _year;
    int _month;
    int _day;
    Date(int year = 1, int month = 1, int day = 1) : _year(year), _month(month), _day(day) {}
    ~Date() { std::cout << "~Date()" << std::endl; }
};

template <class T>
class DeleteArray {
public:
    void operator()(T* ptr) { delete[] ptr; }
};

class Fclose {
public:
    void operator()(FILE* ptr) {
        std::cout << "fclose:" << ptr << std::endl;
        fclose(ptr);
    }
};

int main() {
    bit::shared_ptr<Date> sp1(new Date);
    bit::shared_ptr<Date> sp2(sp1);
    bit::shared_ptr<Date> sp3(new Date);
    sp1 = sp3;
    // 传了删除器，就用自己传的，没传就用缺省的
    bit::shared_ptr<FILE> sp5(fopen("test.cpp", "r"), Fclose());
    bit::shared_ptr<int> sp6((int*)malloc(40), [](int* ptr) {
        std::cout << "free:" << ptr << std::endl;
        free(ptr);
    });
    return 0;
}