C++ 智能指针的使用及其原理

1. 智能指针的使用场景分析

下面程序中我们可以看到，new 了以后，我们也 delete 了，但是因为抛异常导致后面的 delete 没有得到执行，所以就内存泄漏了。因此我们需要 new 以后捕获异常，捕获到异常后 delete 内存，再把异常抛出。但 new 本身也可能抛异常，连续的两个 new 和下面的 Divide 都可能会抛异常，让处理变得很麻烦。智能指针放到这样的场景里就让问题简单多了。

double Divide(int a, int b) { // 当 b == 0 时抛出异常
    if (b == 0) {
        throw "Divide by zero condition!";
    } else {
        return (double)a / (double)b;
    }
}

void Func() {
    // 这里可以看到如果发生除 0 错误抛出异常，另外下面的 array 和 array2 没有得到释放。
    // 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再重新抛出去。
    // 但是如果 array2 new 的时候抛异常呢，就还需要套一层捕获释放逻辑，这里更好解决方案
    // 是智能指针，否则代码太繁琐了
    int* array1 = new int[10];
    int* array2 = new int[10];
    // 抛异常呢
    try {
        int len, time;
        cin >> len >> time;
        cout << Divide(len, time) << endl;
    } catch (...) {
        cout << "delete []" << array1 << endl;
        cout << "delete []" << array2 << endl;
        delete[] array1;
        delete[] array2;
        throw; // 异常重新抛出，捕获到什么抛出什么
    }
    // ...
    cout << "delete []" << array1 << endl;
    delete[] array1;
    cout << "delete []" << array2 << endl;
    delete[] array2;
}

int main() {
    try {
        Func();
    } catch (const char* errmsg) {
        cout << errmsg << endl;
    } catch (const exception& e) {
        cout << e.what() << endl;
    } catch (...) {
        cout << "未知异常" << endl;
    }
    return 0;
}

2. RAII 和智能指针的设计思路

• RAII 是 Resource Acquisition Is Initialization 的缩写，它是一种管理资源的类的设计思想，本质是一种利用对象生命周期来管理获取到的动态资源，避免资源泄漏。这里的资源可以是内存、文件指针、网络连接、互斥锁等等。RAII 在获取资源时把资源委托给一个对象，接着控制对资源的访问，资源在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源，这样保障了资源的正常释放，避免资源泄漏问题。
• 智能指针类除了满足 RAII 的设计思路，还要方便资源的访问，所以智能指针类还会像迭代器类一样，重载 operator*、operator->、operator[] 等运算符，方便访问资源。

template<class T> class SmartPtr {
public:
    // RAII：获取资源时初始化对象
    SmartPtr(T* ptr) :_ptr(ptr) {}
    // 析构时释放资源
    ~SmartPtr() { cout << "delete[] " << _ptr << endl; delete[] _ptr; }
    // 重载运算符，模拟指针的行为，方便访问资源
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    T& operator[](size_t i) { return _ptr[i]; }
private:
    T* _ptr;
};

double Divide(int a, int b) {
    // 当 b == 0 时抛出异常
    if (b == 0) {
        throw "Divide by zero condition!";
    } else {
        return (double)a / (double)b;
    }
}

void Func() {
    // 这里使用 RAII 的智能指针类管理 new 出来的数组以后，程序简单多了
    SmartPtr<int> sp1 = new int[10];
    SmartPtr<int> sp2 = new int[10];
    for (size_t i = 0; i < 10; i++) {
        sp1[i] = sp2[i] = i;
    }
    int len, time;
    cin >> len >> time;
    cout << Divide(len, time) << endl;
}

int main() {
    try {
        Func();
    } catch (const char* errmsg) {
        cout << errmsg << endl;
    } catch (const exception& e) {
        cout << e.what() << endl;
    } catch (...) {
        cout << "未知异常" << endl;
    }
    return 0;
}

3. C++ 标准库智能指针的使用

• C++ 标准库中的智能指针都在 <memory> 这个头文件下面，包含 <memory> 就可以使用了。智能指针有好几种，除了 weak_ptr，它们都符合 RAII 和像指针一样访问的行为，原理上而言主要是解决智能指针拷贝时的思路不同。
• auto_ptr 是 C++98 时设计出来的智能指针，它的特点是拷贝时把被拷贝对象的资源的管理权转移给拷贝对象，这是一个非常糟糕的设计，因为会导致被拷贝对象悬空，访问报错。C++11 设计出新的智能指针后，强烈建议不要使用 auto_ptr。C++11 出来之前很多公司也明令禁止使用这个智能指针。
• unique_ptr 是 C++11 设计出来的智能指针，名字翻译为'唯一指针'，特点是不支持拷贝，只支持移动。如果不需要拷贝的场景，非常建议使用它。
• shared_ptr 是 C++11 设计出来的智能指针，名字翻译为'共享指针'，特点是支持拷贝和移动。如果需要拷贝的场景，需要使用它，底层用引用计数的方式实现。
• weak_ptr 是 C++11 设计出来的智能指针，名字翻译为'弱指针'，完全不同于上面的智能指针，它不支持 RAII，意味着不能用它直接管理资源。weak_ptr 的产生本质是要解决 shared_ptr 的循环引用导致内存泄漏的问题。
• 智能指针析构时默认进行 delete 释放资源，因此如果不是 new 出来的资源交给智能指针管理，析构时会崩溃。智能指针支持在构造时传入一个删除器（本质是可调⽤对象），在智能指针析构时会调用删除器释放资源。因为 new [] 经常使用，所以 unique_ptr 和 shared_ptr 都特化了一份 [] 的版本，使用时 unique_ptr<Date[]> up1(new Date[5]);、shared_ptr<Date[]> sp1(new Date[5]); 就可以管理 new [] 的资源。
• template <class T, class... Args> shared_ptr<T> make_shared(Args&&... args);：shared_ptr 除了支持用指向资源的指针构造，还支持 make_shared 用初始化资源对象的值直接构造。
• shared_ptr 和 unique_ptr 都支持了 operator bool 的类型转换，如果智能指针对象是空对象（没有管理资源），则返回 false，否则返回 true，意味着可以直接把智能指针对象用于 if 判断是否为空。
• shared_ptr 和 unique_ptr 的构造函数都使用 explicit 修饰，防止普通指针隐式类型转换为智能指针对象。

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() { cout << "~Date()" << endl; }
};

int main() {
    auto_ptr<Date> ap1(new Date); // 拷贝时，管理权限转移，被拷贝对象 ap1 悬空
    auto_ptr<Date> ap2(ap1);      // 空指针访问，ap1 对象已经悬空，禁止访问
    // ap1->_year++;

    unique_ptr<Date> up1(new Date); // 不支持拷贝，编译报错
    // unique_ptr<Date> up2(up1);
    // 支持移动，但是移动后 up1 悬空，使用移动要谨慎
    unique_ptr<Date> up3(move(up1));

    shared_ptr<Date> sp1(new Date); // 支持拷贝
    shared_ptr<Date> sp2(sp1);
    shared_ptr<Date> sp3(sp2);
    cout << sp1.use_count() << endl; // 输出 3
    sp1->_year++;
    cout << sp1->_year << endl; // 输出 2
    cout << sp2->_year << endl; // 输出 2
    cout << sp3->_year << endl; // 输出 2
    // 支持移动，移动后 sp1 悬空，使用移动要谨慎
    shared_ptr<Date> sp4(move(sp1));
    return 0;
}

// 自定义删除器：函数指针（用于 new[] 资源）
template<class T>
void DeleteArrayFunc(T* ptr) {
    delete[] ptr;
}

// 自定义删除器：仿函数（用于 new[] 资源）
template<class T>
class DeleteArray {
public:
    void operator()(T* ptr) { delete[] ptr; }
};

// 自定义删除器：仿函数（用于文件指针资源）
class Fclose {
public:
    void operator()(FILE* ptr) {
        cout << "fclose:" << ptr << endl;
        fclose(ptr);
    }
};

int main() {
    // 错误用法：默认 delete 释放 new[] 资源，程序崩溃
    // unique_ptr<Date> up1(new Date[10]);
    // shared_ptr<Date> sp1(new Date[10]);

    // 解决方案 1：使用智能指针的 new[] 特化版本
    unique_ptr<Date[]> up1(new Date[5]);
    shared_ptr<Date[]> sp1(new Date[5]);

    // 解决方案 2：仿函数对象做删除器
    unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);
    shared_ptr<Date> sp2(new Date[5], DeleteArray<Date>());

    // 解决方案 3：函数指针做删除器
    unique_ptr<Date, void(*)(Date*)> up3(new Date[5], DeleteArrayFunc<Date>);
    shared_ptr<Date> sp3(new Date[5], DeleteArrayFunc<Date>);

    // 解决方案 4：lambda 表达式做删除器
    auto delArrOBJ = [](Date* ptr) { delete[] ptr; };
    unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);
    shared_ptr<Date> sp4(new Date[5], delArrOBJ);

    // 管理其他资源（文件指针）
    shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), Fclose());
    shared_ptr<FILE> sp6(fopen("Test.cpp", "r"), [](FILE* ptr) {
        cout << "fclose:" << ptr << endl;
        fclose(ptr);
    });
    return 0;
}

int main() {
    shared_ptr<Date> sp1(new Date(2024, 9, 11));
    shared_ptr<Date> sp2 = make_shared<Date>(2024, 9, 11);
    auto sp3 = make_shared<Date>(2024, 9, 11);
    shared_ptr<Date> sp4;
    // 支持 operator bool 判断是否为空
    if (sp1) cout << "sp1 is not nullptr" << endl;
    if (!sp4) cout << "sp4 is nullptr" << endl;
    // 错误：explicit 修饰构造函数，禁止隐式转换
    // shared_ptr<Date> sp5 = new Date(2024, 9, 11);
    // unique_ptr<Date> sp6 = new Date(2024, 9, 11);
    return 0;
}

4. 智能指针的原理

下面模拟实现了 auto_ptr 和 unique_ptr 的核心功能，这两个智能指针的实现比较简单，了解原理即可。auto_ptr 的思路是拷贝时转移资源管理权给被拷贝对象，这种思路不被认可，不建议使用。unique_ptr 的思路是不支持拷贝。重点要理解 shared_ptr 的设计，尤其是引用计数的设计：一份资源对应一个引用计数，因此引用计数不能用静态成员实现，需要用堆上动态开辟的方式。构造智能指针对象时，每管理一份新资源，就 new 一个引用计数。多个 shared_ptr 指向同一资源时，引用计数 ++；shared_ptr 对象析构时，引用计数 --；引用计数减到 0 时，代表当前是最后一个管理该资源的对象，析构资源。

namespace bit {
    // 模拟实现 auto_ptr（不推荐使用）
    template<class T>
    class auto_ptr {
    public:
        auto_ptr(T* ptr) :_ptr(ptr) {}
        // 拷贝构造：转移资源管理权
        auto_ptr(auto_ptr<T>& ap) :_ptr(ap._ptr) { ap._ptr = nullptr; }
        // 赋值运算符：转移资源管理权
        auto_ptr<T>& operator=(auto_ptr<T>& ap) {
            // 检测是否为自己给自己赋值
            if (this != &ap) {
                // 释放当前对象中资源
                if (_ptr) delete _ptr;
                // 转移 ap 中资源到当前对象中
                _ptr = ap._ptr;
                ap._ptr = NULL;
            }
            return *this;
        }
        ~auto_ptr() {
            if (_ptr) {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
            }
        }
        // 像指针一样使用
        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }
    private:
        T* _ptr;
    };

    // 模拟实现 unique_ptr（禁止拷贝，支持移动）
    template<class T>
    class unique_ptr {
    public:
        explicit unique_ptr(T* ptr) :_ptr(ptr) {}
        ~unique_ptr() {
            if (_ptr) {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
            }
        }
        // 像指针一样使用
        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }
        // 禁止拷贝（删除拷贝构造和赋值运算符）
        unique_ptr(const unique_ptr<T>& sp) = delete;
        unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;
        // 支持移动构造
        unique_ptr(unique_ptr<T>&& sp) :_ptr(sp._ptr) { sp._ptr = nullptr; }
        // 支持移动赋值
        unique_ptr<T>& operator=(unique_ptr<T>&& sp) {
            delete _ptr;
            _ptr = sp._ptr;
            sp._ptr = nullptr;
            return *this;
        }
    private:
        T* _ptr;
    };

    // 模拟实现 shared_ptr（支持拷贝，引用计数）
    template<class T>
    class shared_ptr {
    public:
        // 构造函数：默认初始化或传入资源指针
        explicit 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) {}
        // 拷贝构造：引用计数++
        shared_ptr(const shared_ptr<T>& sp) :_ptr(sp._ptr), _pcount(sp._pcount), _del(sp._del) {
            ++(*_pcount);
        }
        // 释放资源：引用计数--，为 0 时释放资源和引用计数
        void release() {
            if (--(*_pcount) == 0) {
                // 最后一个管理资源的对象，释放资源
                _del(_ptr);
                delete _pcount;
                _ptr = nullptr;
                _pcount = nullptr;
            }
        }
        // 赋值运算符：引用计数转移
        shared_ptr<T>& operator=(const shared_ptr<T>& sp) {
            if (_ptr != sp._ptr) {
                release();
                _ptr = sp._ptr;
                _pcount = sp._pcount;
                ++(*_pcount);
                _del = sp._del;
            }
            return *this;
        }
        ~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;             // 引用计数（堆上开辟，多个对象共享）
        // atomic<int>* _pcount;   // 线程安全的引用计数（原子操作）
        function<void(T*)> _del = [](T* ptr) { delete ptr; }; // 默认删除器
    };

    // 模拟实现 weak_ptr（辅助 shared_ptr，解决循环引用）
    // 注意：此处为简化实现，无法完全实现标准 weak_ptr 的所有功能（如 lock）
    template<class T>
    class weak_ptr {
    public:
        weak_ptr() {}
        // 从 shared_ptr 构造，不增加引用计数
        weak_ptr(const shared_ptr<T>& sp) :_ptr(sp.get()) {}
        // 从 shared_ptr 赋值，不增加引用计数
        weak_ptr<T>& operator=(const shared_ptr<T>& sp) {
            _ptr = sp.get();
            return *this;
        }
    private:
        T* _ptr = nullptr;
    };
}

// 测试模拟实现的智能指针
int main() {
    bit::auto_ptr<Date> ap1(new Date); // 拷贝时，管理权限转移，被拷贝对象 ap1 悬空
    bit::auto_ptr<Date> ap2(ap1);      // 空指针访问，ap1 对象已经悬空，禁止访问
    // ap1->_year++;

    bit::unique_ptr<Date> up1(new Date); // 不支持拷贝，编译报错
    // bit::unique_ptr<Date> up2(up1);
    // 支持移动，移动后 up1 悬空，使用需谨慎
    bit::unique_ptr<Date> up3(move(up1));

    bit::shared_ptr<Date> sp1(new Date); // 支持拷贝，引用计数递增
    bit::shared_ptr<Date> sp2(sp1);
    bit::shared_ptr<Date> sp3(sp2);
    cout << sp1.use_count() << endl;     // 输出 3
    sp1->_year++;
    cout << sp1->_year << endl;          // 输出 2
    cout << sp2->_year << endl;          // 输出 2
    cout << sp3->_year << endl;          // 输出 2
    return 0;
}

5. shared_ptr 和 weak_ptr

5.1 shared_ptr 循环引用问题

shared_ptr 大多数情况下管理资源非常合适，支持 RAII 和拷贝，但在循环引用的场景下会导致资源无法释放，造成内存泄漏。需要认识循环引用的场景和资源未释放的原因，并学会使用 weak_ptr 解决该问题。

循环引用场景分析：

1. 右边的节点何时释放？由左边节点的_next 管理，_next 析构后，右边节点才释放；
2. _next 何时析构？_next 是左边节点的成员，左边节点释放后，_next 才析构；
3. 左边的节点何时释放？由右边节点的_prev 管理，_prev 析构后，左边节点才释放；
4. _prev 何时析构？_prev 是右边节点的成员，右边节点释放后，_prev 才析构。

至此形成循环引用，两个节点互相依赖，谁都无法释放，导致内存泄漏。解决方案：把 ListNode 结构体中的_next 和_prev 改成 weak_ptr。weak_ptr 绑定到 shared_ptr 时不会增加引用计数，不参与资源释放管理逻辑，从而打破循环引用。

struct ListNode {
    int _data;
    // 循环引用：shared_ptr 互相指向，导致内存泄漏
    std::shared_ptr<ListNode> _next;
    std::shared_ptr<ListNode> _prev;
    // 解决方案：改用 weak_ptr，不增加引用计数
    /*std::weak_ptr<ListNode> _next;
    std::weak_ptr<ListNode> _prev;*/
    ~ListNode() { cout << "~ListNode()" << endl; }
};

int main() {
    // 循环引用 -- 内存泄露
    std::shared_ptr<ListNode> n1(new ListNode);
    std::shared_ptr<ListNode> n2(new ListNode);
    cout << n1.use_count() << endl; // 输出 1
    cout << n2.use_count() << endl; // 输出 1
    n1->_next = n2;
    n2->_prev = n1;
    cout << n1.use_count() << endl; // 输出 2
    cout << n2.use_count() << endl; // 输出 2
    // weak_ptr 不支持管理资源，不支持 RAII
    // weak_ptr 是专门绑定 shared_ptr，不增加其引用计数，作为辅助管理
    // std::weak_ptr<ListNode> wp(new ListNode); // 编译报错，不能直接绑定资源
    return 0;
}

5.2 weak_ptr

weak_ptr 不支持 RAII，也不支持直接访问资源（未重载 operator* 和 operator->）。其构造时不支持绑定到资源，只支持绑定到 shared_ptr，且绑定后不增加 shared_ptr 的引用计数，专门用于解决 shared_ptr 的循环引用问题。

weak_ptr 的常用接口：

• expired ()：检查指向的资源是否过期（即对应的 shared_ptr 是否已释放资源）；
• use_count ()：获取对应的 shared_ptr 的引用计数；
• lock ()：尝试获取资源的管理权，返回一个 shared_ptr。若资源已释放，返回空的 shared_ptr；若资源未释放，返回的 shared_ptr 可安全访问资源。

int main() {
    std::shared_ptr<string> sp1(new string("111111"));
    std::shared_ptr<string> sp2(sp1);
    std::weak_ptr<string> wp = sp1;
    cout << wp.expired() << endl; // 输出 0（资源未过期）
    cout << wp.use_count() << endl; // 输出 2
    // sp1 指向新资源，原资源的引用计数变为 1
    sp1 = make_shared<string>("222222");
    cout << wp.expired() << endl; // 输出 0（原资源仍未过期）
    cout << wp.use_count() << endl; // 输出 1
    // sp2 指向新资源，原资源的引用计数变为 0，资源释放
    sp2 = make_shared<string>("333333");
    cout << wp.expired() << endl; // 输出 1（原资源已过期）
    cout << wp.use_count() << endl; // 输出 0
    // 重新绑定新资源
    wp = sp1;
    auto sp3 = wp.lock(); // 获取资源管理权，sp1 的引用计数变为 2
    cout << wp.expired() << endl; // 输出 0（新资源未过期）
    cout << wp.use_count() << endl; // 输出 2
    *sp3 += "###";
    cout << *sp1 << endl; // 输出"222222###"
    return 0;
}

6. shared_ptr 的线程安全问题

• shared_ptr 的引用计数对象在堆上，如果多个线程中存在 shared_ptr 的拷贝或析构操作，会导致多个线程同时访问和修改引用计数，存在线程安全问题。因此 shared_ptr 的引用计数需要通过加锁或原子操作保证线程安全。
• shared_ptr 指向的对象本身存在线程安全问题，但该问题不归 shared_ptr 管理，需由外层使用者通过加锁等方式控制。

解决引用计数的线程安全问题：将模拟实现的 shared_ptr 中的 int* _pcount 改为 atomic<int>* _pcount（原子操作），或使用互斥锁加锁保护引用计数的修改。

struct AA {
    int _a1 = 0;
    int _a2 = 0;
    ~AA() { cout << "~AA()" << endl; }
};

int main() {
    bit::shared_ptr<AA> p(new AA);
    const size_t n = 100000;
    mutex mtx;
    auto func = [&]() {
        for (size_t i = 0; i < n; ++i) {
            // 智能指针拷贝会++引用计数（线程不安全，需原子操作或加锁）
            bit::shared_ptr<AA> copy(p);
            {
                unique_lock<mutex> lk(mtx);
                // 保护对象的线程安全
                copy->_a1++;
                copy->_a2++;
            }
        }
    };
    thread t1(func);
    thread t2(func);
    t1.join();
    t2.join();
    cout << p->_a1 << endl; // 预期输出 200000
    cout << p->_a2 << endl; // 预期输出 200000
    cout << p.use_count() << endl; // 输出 1
    return 0;
}

7. C++11 和 boost 中智能指针的关系

• Boost 库是为 C++ 标准库提供扩展的 C++ 程序库总称，Boost 社区的初衷之一是为 C++ 标准化工作提供参考实现，Boost 社区发起人 Dawes 是 C++ 标准委员会成员之一。C++11 及之后的新语法和库很多都源自 Boost。
• C++ 98：产生第一个智能指针 auto_ptr；
• Boost 库：提供更实用的 scoped_ptr/scoped_array、shared_ptr/shared_array、weak_ptr 等；
• C++ TR1：引入 shared_ptr 等，但 TR1 并非标准版；
• C++ 11：引入 unique_ptr、shared_ptr、weak_ptr（其中 unique_ptr 对应 Boost 的 scoped_ptr），其实现原理参考了 Boost 中的智能指针。

8. 内存泄漏

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

• 什么是内存泄漏：指因疏忽或错误导致程序未能释放不再使用的内存。通常是忘记释放内存，或因异常导致释放代码未能执行。内存泄漏并非物理内存消失，而是程序分配内存后失去控制，造成内存浪费。
• 内存泄漏的危害：
  • 普通短时运行程序：影响较小，进程结束后操作系统会回收所有资源；
  • 长期运行程序（如操作系统、后台服务、长时间运行的客户端）：内存泄漏会导致可用内存持续减少，程序响应变慢，最终卡死。

int main() {
    // 申请 1G 内存未释放，程序运行后立即结束，资源会被系统回收，无明显危害
    char* ptr = new char[1024 * 1024 * 1024];
    cout << (void*)ptr << endl;
    return 0;
}