C++ 智能指针：使用场景、实现原理与内存泄漏防治

二、RAII 和智能指针的设计思路

RAII（Resource Acquisition Is Initialization，资源获取即初始化）是一种利用对象生命周期来管理动态资源的设计思想。资源可以是内存、文件句柄、网络连接或互斥锁等。

核心逻辑是：在构造对象时获取资源，在析构对象时释放资源。无论是正常退出还是异常退出栈帧，析构函数都会被调用，从而保证资源被正确释放。

智能指针类除了满足 RAII 设计，还会重载运算符（如 *, ->, []），使其行为像普通指针一样方便访问资源。

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;
};

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;
    // 即使这里抛出异常，sp1 和 sp2 的析构函数也会自动调用，释放内存
}

三、C++ 标准库智能指针的使用

C++ 标准库中的智能指针都在 <memory> 头文件中。主要有以下几种：

1. auto_ptr (已废弃)

C++98 时期的产物，采用破坏性拷贝策略：拷贝时转移所有权，原指针置空。这容易导致悬空指针访问，C++11 后强烈建议不再使用。

2. unique_ptr (唯一指针)

C++11 引入，基于移动语义。不支持拷贝，只支持移动（右值）。适用于独占资源的场景，性能最好。

3. shared_ptr (共享指针)

C++11 引入，支持拷贝和移动。底层通过引用计数实现多指针共享同一资源。当引用计数归零时自动释放资源。缺点是有一定的性能开销。

4. weak_ptr (弱指针)

不管理资源，不增加引用计数。主要用于解决 shared_ptr 的循环引用问题。

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

int main() {
    // unique_ptr 不支持拷贝
    unique_ptr<Date> up1(new Date);
    unique_ptr<Date> up3(move(up1)); // 支持移动

    // shared_ptr 支持拷贝，引用计数会增加
    shared_ptr<Date> sp1(new Date);
    shared_ptr<Date> sp2(sp1); // 引用计数变为 2
    cout << sp1.use_count() << endl;

    // make_shared 优化：将控制块和资源分配在同一块内存，减少碎片
    shared_ptr<Date> sp2_make = make_shared<Date>(2024, 9, 11);

    // 类型转换判断是否为空
    if (sp1) cout << "sp1 is not nullptr" << endl;
    if (!sp2_make) cout << "sp2_make is nullptr" << endl;

    return 0;
}

其他重要说明：

• make_shared: 相比直接 new，效率更高，因为它将计数器与资源放在一起分配。
• operator bool: 支持隐式转换为 bool，可用于 if 判断指针有效性。
• explicit 构造函数: 防止普通指针隐式转换为智能指针，强制显式管理所有权。
• 定制删除器: 默认析构使用 delete。对于 new[] 或 malloc 等资源，需指定匹配的删除器（如 delete[] 或 free）。unique_ptr 特化了数组版本，shared_ptr 则通过模板参数支持自定义删除器。

四、智能指针的原理

1. 基本功能实现

智能指针的核心是析构时释放资源。需要判断资源是否为空，不为空再 delete。

2. 引用计数实现

不能简单使用静态成员变量计数，因为每份资源需要独立的计数器。最佳方案是创建一个 int* 指向动态开辟的整型变量作为计数器。

• 拷贝构造: 复制指针和计数器地址，并将计数器加一。
• 析构: 将计数器减一，若为 0，则释放资源和计数器。

3. 赋值运算符重载

赋值前需先释放当前对象持有的资源（计数器减一，若为 0 则释放）。同时需处理自赋值情况（判断是否指向同一资源）。

4. 定制删除器实现

为了支持非 new 分配的资源（如 malloc），需要引入可调用对象作为删除器。通常使用 std::function<void(T*)> 存储删除器，并在析构时调用。

namespace wusaqi {
template<class T>
class shared_ptr {
public:
    // 默认构造
    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);
    }

    // 释放资源逻辑
    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;
            _del = sp._del;
            ++(*_pcount);
        }
        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 = nullptr;
    int* _pcount;
    function<void(T*)> _del = [](T* ptr){ delete ptr; };
};
}

五、shared_ptr 和 weak_ptr

1. shared_ptr 循环引用问题

当两个对象互相持有对方的 shared_ptr 时，引用计数永远无法归零，导致内存泄漏。

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

int main() {
    std::shared_ptr<ListNode> n1(new ListNode);
    std::shared_ptr<ListNode> n2(new ListNode);
    n1->_next = n2;
    n2->_prev = n1;
    // 此时 n1 和 n2 的引用计数均为 2，互相持有，无法释放
    return 0;
}

2. weak_ptr 解决方案

weak_ptr 不管理资源，不增加引用计数，仅作为观察者。它绑定到 shared_ptr 但不参与所有权管理，从而打破循环引用。

访问 weak_ptr 绑定的资源时，需调用 lock() 方法，它会返回一个临时的 shared_ptr。如果资源已被释放，返回空指针，避免悬垂指针风险。

struct ListNode {
    int _data;
    std::weak_ptr<ListNode> _next; // 改为 weak_ptr
    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);
    n1->_next = n2;
    n2->_prev = n1;
    // 此时 n1 和 n2 的引用计数均为 1，可以正常释放
    return 0;
}

// 安全访问示例
auto sp3 = wp.lock();
if (sp3) {
    *sp3 += "###";
}

六、内存泄漏

1. 什么是内存泄漏

内存泄漏指程序未能释放已经不再使用的内存。常见原因包括忘记释放、异常路径未处理等。虽然短期运行的程序影响不大，但长期运行的服务（如操作系统、后台进程）若存在泄漏，会导致可用内存减少，响应变慢甚至崩溃。

2. 如何避免内存泄漏

• 事前预防: 养成良好的编码规范，尽量使用智能指针管理资源。遵循 RAII 思想，确保资源获取与释放匹配。
• 事后检测: 定期使用内存泄漏检测工具（如 Valgrind, AddressSanitizer）扫描代码，尤其在上线前。

总结来说，内存泄漏的解决方案分为两类：一是通过智能指针等机制进行事前预防；二是借助专业工具进行事后查错。在现代 C++ 开发中，优先推荐使用智能指针替代裸指针，能大幅降低此类风险。