C++智能指针的日常：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 智能指针后，无需手动 delete，异常也能安全释放
    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;
    }
    // 即使 Divide 抛异常，sp1 和 sp2 析构时也会自动释放内存
    int len, time;
    cin >> len >> time;
    cout << Divide(len, time) << endl;
}

这个 SmartPtr 只是个玩具，功能薄弱，但它展示了核心思路。标准库提供的智能指针更健壮，能满足各种场景。

标准库中的智能指针

C++11 之后，<memory> 带给我们三位一体：unique_ptr、shared_ptr 和 weak_ptr。auto_ptr 已经退休，别用了。

unique_ptr：独占所有权

unique_ptr 不允许拷贝，只能移动。性能上跟裸指针一样，因为我通常只在一个地方持有资源，所以它是我默认的选择。

unique_ptr<Date> up1(new Date);
// unique_ptr<Date> up2(up1); // 错误：禁止拷贝
unique_ptr<Date> up3(move(up1)); // 正确：移动后 up1 悬空

shared_ptr：共享所有权

需要多个地方共享同一对象时登场。内部用引用计数，计数归零自动释放。为了方便和效率，我倾向于用 make_shared，它会一次性分配对象和控制块，减少内存碎片。

shared_ptr<Date> sp1(new Date);
shared_ptr<Date> sp2(sp1); // 引用计数 +1
shared_ptr<Date> sp3(sp2); // 引用计数 +1
cout << sp1.use_count() << endl; // 输出 3

// 更推荐的写法
shared_ptr<Date> sp1 = make_shared<Date>(2024, 9, 11);

weak_ptr：弱引用救场

weak_ptr 不增加引用计数，专门用来掰直 shared_ptr 的循环引用。它只是'观察者'，需要访问资源时得先 lock() 一个 shared_ptr 出来，如果资源已释放，lock() 返回空。

定制删除器

默认的删除器用 delete，但 new[] 或 malloc 的资源需要配对的释放方式。下面是指定 delete[] 的做法：

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

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

怎么实现的？

光用不过瘾，拆一个极简版看看原理。

unique_ptr 核心

禁止拷贝，允许移动，析构时 delete。实现简单：

template<class T>
class unique_ptr {
public:
    explicit unique_ptr(T* ptr) : _ptr(ptr) {}
    ~unique_ptr() { if (_ptr) { delete _ptr; _ptr = nullptr; } }

    // 禁用拷贝
    unique_ptr(const unique_ptr<T>&) = delete;
    unique_ptr<T>& operator=(const unique_ptr<T>&) = 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:
    shared_ptr(T* ptr = nullptr) : _ptr(ptr), _pcount(new int(1)) {}

    shared_ptr(const shared_ptr<T>& sp) : _ptr(sp._ptr), _pcount(sp._pcount) {
        ++(*_pcount); // 拷贝时计数加一
    }

    ~shared_ptr() {
        release();
    }

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

private:
    T* _ptr;
    int* _pcount;
    function<void(T*)> _del = [](T* ptr){ delete ptr; }; // 默认删除器
};

真正的实现远比这复杂（要考虑线程安全、weak_ptr 等），但骨架如此。

循环引用：shared_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 引用计数变为 2
    n2->_prev = n1; // n1 引用计数变为 2
    // 析构时，两者计数均为 2，永远不会释放
    return 0;
}

两个节点互相攥着对方，引用计数就永远不会归零——内存就这么悄悄泄漏了。解决方法就是把其中一个方向的 shared_ptr 换成 weak_ptr：

struct ListNode {
    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 引用计数仍为 1
    n2->_prev = n1; // n1 引用计数仍为 1
    // 析构时，计数归零，资源正常释放
    return 0;
}

weak_ptr 不增加计数，只是旁观的。要访问资源时，必须调用 lock() 提升为临时 shared_ptr，如果原始资源已释放，就会得到一个空的 shared_ptr。

内存泄漏：预防比检测更重要

泄漏就是占着内存不还。对于长期运行的服务，小漏也能积累成大患。现代 C++ 已经把战场从手动释放变成了智能指针的战场，但我们还是得知道几件事：

• 优先用智能指针：只要有可能，就别用裸 new/delete。RAII 能自动搞定。
• 保持所有权清晰：谁创建谁释放的法则换成智能指针就是明确所有权模型。
• 异常路径不用怕：智能指针在栈展开时自动析构，不用再写一堆 catch。
• 事后检测：如果用 Valgrind 或 AddressSanitizer 查泄漏，最好先确保代码里裸指针已经绝迹。

智能指针用熟了，写出的代码就会更结实。