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

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)

auto_ptr 采用破坏性拷贝策略：拷贝时所有权转移，原指针置为 nullptr。这容易导致悬空指针访问，C++11 后强烈建议弃用。

2. unique_ptr (C++11)

unique_ptr 表示独占所有权，不支持拷贝，仅支持移动语义（右值）。适用于不需要共享资源的场景，性能开销最小。

3. shared_ptr (C++11)

shared_ptr 支持拷贝和移动，底层通过引用计数实现资源共享。当引用计数降为 0 时自动释放资源。需注意其有一定的性能开销，若仅需移动资源，优先使用 unique_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)); // 移动后 up1 变为空

    // shared_ptr 支持拷贝
    shared_ptr<Date> sp1(new Date);
    shared_ptr<Date> sp2(sp1); // 引用计数 +1
    cout << sp1.use_count() << endl; // 输出 2
    
    // make_shared 优化内存碎片
    shared_ptr<Date> sp4 = make_shared<Date>(2024, 9, 11);
    return 0;
}

其他关键特性

• make_shared: 相比直接 new，它将控制块和资源分配在同一块内存中，减少内存碎片，效率更高。
• operator bool: 支持隐式转换为 bool，可用于判断指针是否为空。
• explicit 构造函数: 防止普通指针隐式转换为智能指针，强制显式管理所有权。
• 自定义删除器: 默认析构使用 delete。对于 new[] 或 malloc 等资源，需传入匹配的删除器（如 std::default_delete<T[]> 或 lambda 表达式）。

// 管理 new[] 资源
unique_ptr<Date[]> up1(new Date[5]);

// 自定义删除器 (lambda)
auto delArrOBJ = [](Date* ptr){ delete[] ptr; };
unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);

四、智能指针的原理

1. 基础实现

智能指针的核心是在析构时释放资源。需判断资源是否为空，避免重复释放。

2. 引用计数实现 shared_ptr

为了实现多指针共享同一资源，不能仅靠静态计数器（所有对象共用），而应为每份资源分配独立的计数器。

• 结构: 包含指向资源的指针 _ptr 和指向引用计数的指针 _pcount。
• 拷贝构造: 复制指针，并将计数器加一。
• 析构: 将计数器减一，若为 0 则同时释放资源和计数器。
• 赋值运算符: 先释放当前资源（若不再需要），再指向新资源并更新计数。

3. 定制删除器实现

为了支持非 new 分配的资源，shared_ptr 允许在构造时传入删除器。通常使用 std::function<void(T*)> 存储可调用对象，默认值为 delete。

五、shared_ptr 和 weak_ptr

循环引用问题

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

weak_ptr 解决方案

weak_ptr 不管理资源所有权，不增加引用计数，专门用于观察 shared_ptr 管理的对象。

• 打破循环: 将循环引用中的一方改为 weak_ptr，使其不参与引用计数。
• 安全性: weak_ptr 不能直接访问资源，需调用 lock() 方法尝试获取临时的 shared_ptr。若资源已释放，lock() 返回空指针，避免悬垂指针。

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

// 安全访问
if (auto sp = wp.lock()) {
    // 安全访问资源
} else {
    // 资源已过期
}

六、内存泄漏

什么是内存泄漏

内存泄漏指程序未能释放不再使用的内存。常见于忘记释放或异常路径未清理资源。长期运行的服务若存在泄漏，可用内存会逐渐耗尽，导致系统变慢甚至崩溃。

如何避免

1. 事前预防: 养成良好的编码规范，优先使用智能指针管理资源，遵循 RAII 原则。
2. 事后检测: 定期使用内存泄漏检测工具（如 Valgrind、AddressSanitizer）扫描代码。
3. 异常安全: 确保在异常发生时资源也能正确释放，智能指针天然具备此能力。