#include <iostream>
#include <stdexcept>
 
double Divide(int a, int b)
{
    if (b == 0)
        throw std::runtime_error("divide by zero");
    return static_cast<double>(a) / static_cast<double>(b);
}
 
void Func()
{
    int* array = new int[10];
    int len = 0;
    int time = 0;
    std::cin >> len >> time;
    std::cout << Divide(len, time) << '\n';
    delete[] array;
}
 
int main()
{
    try
    {
        Func();
    }
    catch (const std::exception& e)
    {
        std::cout << e.what() << '\n';
    }
}

delete[] 写在了函数的最后一行。输入 10 0 触发 Divide 里的 throw,这一行就永远到不了。问题不在记性,而在“释放动作绑在代码路径上”这个模型:只要有一条路径提前离开函数,释放就落空。

把释放写进析构函数

RAII(Resource Acquisition Is Initialization)换了个绑法:资源在构造时交给一个对象,在析构时释放。对象在栈上,离开作用域时析构由语言保证,正常返回、提前 return、异常展开都一样。

#include <iostream>
 
template<class T>
class SmartPtr
{
public:
    explicit SmartPtr(T* ptr = nullptr) : _ptr(ptr) {}
 
    ~SmartPtr()
    {
        delete _ptr;
    }
 
    SmartPtr(const SmartPtr&) = delete;
    SmartPtr& operator=(const SmartPtr&) = delete;
 
    T& operator*() const { return *_ptr; }
    T* operator->() const { return _ptr; }
 
private:
    T* _ptr;
};
 
double Divide(int a, int b)
{
    if (b == 0)
        throw "Divide by zero condition!";
    return static_cast<double>(a) / static_cast<double>(b);
}
 
void Func()
{
    SmartPtr<int> number(new int(0));
    int len = 0;
    int time = 0;
    std::cin >> len >> time;
    std::cout << Divide(len, time) << '\n';
}
 
int main()
{
    try
    {
        Func();
    }
    catch (const char* msg)
    {
        std::cout << msg << '\n';
    }
}

两个 = delete 不能省。允许拷贝的话,两个 SmartPtr 析构时会 delete 同一根指针,直接 double free。析构函数里的 delete 也只能配单个对象;如果接管的是 new[],释放形式得是 delete[],否则是未定义行为。

课件里的教学版 SmartPtr 在这两处留了口子:没有禁用拷贝,析构固定写 delete[]。示范代码可以短,但这两条是智能指针的安全底线。

auto_ptr:拷贝就是搬走

C++98 的 auto_ptr 也做独占,但它的“拷贝”会转移管理权:

template<class T>
class auto_ptr
{
public:
    explicit auto_ptr(T* p = nullptr) : _p(p) {}
 
    auto_ptr(auto_ptr& other) : _p(other._p)
    {
        other._p = nullptr;
    }
 
    auto_ptr& operator=(auto_ptr& other)
    {
        if (this != &other)
        {
            delete _p;
            _p = other._p;
            other._p = nullptr;
        }
        return *this;
    }
 
    ~auto_ptr() { delete _p; }
 
    T& operator*() const { return *_p; }
    T* operator->() const { return _p; }
 
private:
    T* _p;
};

执行 auto_ptr<int> b = a; 后,a 变成空指针。副本和原对象并不相等,原对象再被访问就是空指针解引用。它甚至不能安全地放进标准容器,容器拷来拷去可能把资源搬空。std::auto_ptr 在 C++11 被弃用,C++17 正式移除;unique_ptr 把转移改成了显式的 std::move,不再让拷贝偷偷搬东西。

unique_ptr:所有权唯一,删除器在类型里

unique_ptr 不支持拷贝,只支持移动。默认版本只存一个裸指针;删除器如果是空类,还能靠空基类优化不占空间。在常见的 64 位实现上,sizeof(std::unique_ptr<int>) 是 8,sizeof(std::shared_ptr<int>) 是 16。

#include <cstdio>
#include <iostream>
#include <memory>
 
struct Date
{
    int year = 1;
};
 
struct Fclose
{
    void operator()(FILE* f) const noexcept
    {
        if (f != nullptr)
            std::fclose(f);
    }
};
 
int main()
{
    std::unique_ptr<Date> up1(new Date);
    std::unique_ptr<Date> up2(std::move(up1));   // 所有权转移,up1 悬空
    // std::unique_ptr<Date> up3(up2);           // 编译错误:拷贝被删除
 
    up2.reset(new Date);          // 释放旧对象,接管新对象
    Date* raw = up2.release();    // 放弃所有权,返回裸指针
    delete raw;                   // 现在由调用方负责
 
    std::cout << static_cast<bool>(up2) << '\n';   // 0,release 后为空
 
    std::unique_ptr<Date[]> arr(new Date[5]);      // 特化版本用 delete[]
 
    std::unique_ptr<FILE, Fclose> file(std::fopen("data.txt", "rb"));
    std::unique_ptr<FILE, int (*)(FILE*)> file2(std::fopen("data.txt", "rb"), std::fclose);
}

release 只放弃所有权,不清空指向的对象;reset 释放旧资源再接管新的;get 只借出裸指针,不改所有权。swap 交换两个 unique_ptr 的资源。

删除器写进第二个模板参数,unique_ptr<FILE, Fclose> 和 unique_ptr<FILE, decltype(&std::fclose)> 是两种不同类型。删除器长在对象布局里,不需要运行期存储,所以 unique_ptr 能做到零开销。代价是每一种删除器都产生一个新类型;函数指针和 lambda 的类型不同,decltype 在这里很常用。

数组要单独说。unique_ptr<T[]> 从 C++11 就有,析构用 delete[],并提供 operator[]。std::make_unique 是 C++14 补的,C++11 只能写 std::unique_ptr<Date>(new Date)。它不是纯语法糖:把“构造对象”和“构造智能指针”合成一个表达式,避免了 f(unique_ptr<T>(new T), g()) 这种实参求值顺序下的泄漏。

移动赋值要防自移动:

unique_ptr& operator=(unique_ptr&& other) noexcept
{
    if (this != &other)
    {
        delete _p;
        _p = other._p;
        other._p = nullptr;
    }
    return *this;
}

课件的 unique_ptr 移动赋值少了 return *this;。非 void 函数执行到末尾却没有 return,是未定义行为;这份代码在 up = std::move(other) 之后继续用返回值就会出事。同一段里也没有 this != &other 判断,up = std::move(up) 会先删掉自己的资源,再把已经悬空的指针写回去。

shared_ptr:共享的是控制块

shared_ptr 支持拷贝,也支持移动。它保存两样东西:get() 返回的裸指针,以及一个指向控制块的指针。控制块里放着强引用计数、弱引用计数,以及删除器和分配信息。

sp1 和 sp2(sp1) 共享同一份资源与同一个引用计数 2;sp3 单独管理另一份资源,计数是 1,说明拷贝共享的是控制块而不是复制对象

#include <iostream>
#include <memory>
 
int main()
{
    std::shared_ptr<int> sp1(new int(1));
    std::shared_ptr<int> sp2(sp1);
    std::shared_ptr<int> sp3(sp2);
    std::cout << sp1.use_count() << '\n';        // 3
 
    std::shared_ptr<int> sp4(std::move(sp3));
    std::cout << sp3.use_count() << ' '          // 0,源对象被搬空
              << sp4.use_count() << '\n';        // 3
 
    std::shared_ptr<int> sp5 = std::make_shared<int>(5);
    std::cout << (sp5 ? "not null" : "null") << '\n';
}

移动不改变拥有者数量,只把控制块指针从 sp3 挪到 sp4。use_count() 返回强引用数量,调试时有用,不要拿它做同步判断:多线程下读完这个值,下一刻就可能变。

make_shared 把对象和控制块放进同一次分配,少一次 new,也少一次指针跳转;代价是只要还有 weak_ptr 活着,整块内存都不能还。make_shared 也不支持自定义删除器。

用裸指针构造 shared_ptr 时,每个构造函数都会新建一个控制块:

int* raw = new int(42);
std::shared_ptr<int> a(raw);
std::shared_ptr<int> b(raw);   // 第二个控制块,计数各是 1

作用域结束时 b 先析构,计数归零,delete raw;接着 a 也归零,再 delete raw 一次。两个控制块都以为自己是唯一所有者。同理,对象已经由 shared_ptr 管理,成员函数里再写 shared_ptr<T>(this),也会建出第二个控制块。这种场景继承 std::enable_shared_from_this<T>,用 shared_from_this() 复用已有控制块;前提是对象确实被 shared_ptr 接管过。

shared_ptr 的删除器放在构造参数里,不进入类型:

#include <cstdio>
#include <memory>
 
struct Fclose
{
    void operator()(FILE* f) const noexcept
    {
        if (f != nullptr)
            std::fclose(f);
    }
};
 
int main()
{
    std::shared_ptr<FILE> sp1(std::fopen("data.txt", "rb"), Fclose());
    std::shared_ptr<FILE> sp2(std::fopen("data.txt", "rb"),
                              [](FILE* f) { if (f) std::fclose(f); });
}

unique_ptr 要零开销,删除器必须是类型的一部分;shared_ptr 要“同一种类型接任意删除器”,只能把删除器擦进控制块。删除器运行在析构路径上,标准规定它不能抛异常——抛了就是 std::terminate。

shared_ptr<T[]> 是 C++17 才加入的。在 C++11 里写 std::shared_ptr<Date>(new Date[5]),默认删除器仍然是 delete,形式不匹配,行为未定义。要么用 C++17,要么自己给 delete[] 的删除器。

循环引用:两个 shared_ptr 互相等

shared_ptr 最典型的坑是循环引用。两个节点各自用 shared_ptr 指向对方:

#include <iostream>
#include <memory>
 
struct ListNode
{
    int _data = 0;
    std::shared_ptr<ListNode> _next;
    std::shared_ptr<ListNode> _prev;
 
    ~ListNode() { std::cout << "~ListNode\n"; }
};
 
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
 
    std::weak_ptr<ListNode> w1 = n1;
    std::weak_ptr<ListNode> w2 = n2;
 
    n1.reset();
    n2.reset();
 
    std::cout << w1.use_count() << ' ' << w2.use_count() << '\n';   // 1 1
    std::cout << w1.expired() << ' ' << w2.expired() << '\n';       // 0 0
}

循环引用的计数变化:刚建好是 1 和 1;n1->_next = n2、n2->_prev = n1 后变成 2 和 2;外部 n1、n2 析构后各剩 1,两个节点的析构函数都不会执行

外部指针析构后,每边的计数还剩 1,持有者正是对方节点里的成员。右边的节点要等左边节点释放,左边的节点要等右边节点释放,谁都不肯先死,两个 ~ListNode 都不会打印。

把反向指针改成 weak_ptr 就破了:

struct ListNode
{
    int _data = 0;
    std::shared_ptr<ListNode> _next;   // 持有下一个
    std::weak_ptr<ListNode> _prev;     // 只观察上一个
    ~ListNode() { std::cout << "~ListNode\n"; }
};

weak_ptr 绑定到 shared_ptr 时不增加强引用计数,不参与资源释放。n1->next = n2 让 n2 的计数变成 2;n2->prev = n1 只是弱引用,n1 的计数仍是 1。外部 n1 析构后计数归零,节点销毁,它的 next 成员跟着析构,把 n2 的计数减到 0,n2 这才死。析构顺序是反的,但两个都释放了。

weak_ptr 不支持 RAII,不能直接管理资源,也不能用 * 和 -> 访问对象。它提供的操作是:

std::weak_ptr<std::string> wp = sp;
std::cout << wp.expired() << '\n';     // 资源是否已释放
std::cout << wp.use_count() << '\n';   // 当前强引用数
auto sp2 = wp.lock();                  // 提升成 shared_ptr
if (sp2)
    *sp2 += "###";

lock() 是访问资源的唯一入口。它返回一个临时的 shared_ptr:资源还在,这个临时对象保证访问期间对象不被销毁;资源已经释放,返回空对象。标准实现内部用原子操作完成“检查计数并自增”,不能写成“先 expired() 再 ++”,这两步之间别的线程可能放掉最后一个强引用。

手写一个带控制块的 shared_ptr

把强计数和弱计数放进同一个控制块,weak_ptr 才有可能实现 lock。控制块的生命周期由两个计数共同决定:强引用归零时删对象,强弱都归零时删控制块。

#include <atomic>
#include <iostream>
 
namespace bit
{
struct ControlBlock
{
    std::atomic<long> use;
    std::atomic<long> weak;
 
    ControlBlock(long u, long w) : use(u), weak(w) {}
};
 
template<class T>
class weak_ptr;
 
template<class T>
class shared_ptr
{
    friend class weak_ptr<T>;
 
public:
    explicit shared_ptr(T* p = nullptr)
        : _p(p), _cb(p != nullptr ? new ControlBlock(1, 0) : nullptr) {}
 
    shared_ptr(const shared_ptr& other)
        : _p(other._p), _cb(other._cb)
    {
        if (_cb != nullptr)
            ++_cb->use;
    }
 
    shared_ptr(shared_ptr&& other) noexcept
        : _p(other._p), _cb(other._cb)
    {
        other._p = nullptr;
        other._cb = nullptr;
    }
 
    shared_ptr& operator=(const shared_ptr& other)
    {
        if (this != &other)
        {
            Release();
            _p = other._p;
            _cb = other._cb;
            if (_cb != nullptr)
                ++_cb->use;
        }
        return *this;
    }
 
    shared_ptr& operator=(shared_ptr&& other) noexcept
    {
        if (this != &other)
        {
            Release();
            _p = other._p;
            _cb = other._cb;
            other._p = nullptr;
            other._cb = nullptr;
        }
        return *this;
    }
 
    ~shared_ptr()
    {
        Release();
    }
 
    long use_count() const
    {
        return _cb != nullptr ? _cb->use.load() : 0;
    }
 
    T* get() const { return _p; }
    T& operator*() const { return *_p; }
    T* operator->() const { return _p; }
    explicit operator bool() const { return _p != nullptr; }
 
private:
    shared_ptr(T* p, ControlBlock* cb) noexcept
        : _p(p), _cb(cb)
    {
        ++_cb->use;
    }
 
    void Release()
    {
        if (_cb == nullptr)
            return;
 
        if (--_cb->use == 0)
        {
            delete _p;
            _p = nullptr;
            if (_cb->weak == 0)
            {
                delete _cb;
                _cb = nullptr;
            }
        }
        else
        {
            _p = nullptr;
            _cb = nullptr;
        }
    }
 
    T* _p;
    ControlBlock* _cb;
};
 
template<class T>
class weak_ptr
{
public:
    weak_ptr() noexcept = default;
 
    weak_ptr(const shared_ptr<T>& sp) noexcept
        : _p(sp._p), _cb(sp._cb)
    {
        if (_cb != nullptr)
            ++_cb->weak;
    }
 
    weak_ptr(const weak_ptr& other) noexcept
        : _p(other._p), _cb(other._cb)
    {
        if (_cb != nullptr)
            ++_cb->weak;
    }
 
    weak_ptr& operator=(const weak_ptr& other) noexcept
    {
        if (this != &other)
        {
            Release();
            _p = other._p;
            _cb = other._cb;
            if (_cb != nullptr)
                ++_cb->weak;
        }
        return *this;
    }
 
    weak_ptr& operator=(const shared_ptr<T>& sp) noexcept
    {
        Release();
        _p = sp._p;
        _cb = sp._cb;
        if (_cb != nullptr)
            ++_cb->weak;
        return *this;
    }
 
    ~weak_ptr()
    {
        Release();
    }
 
    bool expired() const
    {
        return _cb == nullptr || _cb->use.load() == 0;
    }
 
    long use_count() const
    {
        return _cb != nullptr ? _cb->use.load() : 0;
    }
 
    shared_ptr<T> lock() const
    {
        if (expired())
            return shared_ptr<T>();
        return shared_ptr<T>(_p, _cb);
    }
 
private:
    void Release()
    {
        if (_cb != nullptr && --_cb->weak == 0 && _cb->use.load() == 0)
            delete _cb;
        _p = nullptr;
        _cb = nullptr;
    }
 
    T* _p = nullptr;
    ControlBlock* _cb = nullptr;
};
}
 
int main()
{
    bit::shared_ptr<int> sp1(new int(1));
    bit::shared_ptr<int> sp2(sp1);
    std::cout << sp1.use_count() << '\n';   // 2
 
    bit::weak_ptr<int> wp(sp1);
    std::cout << wp.use_count() << '\n';    // 2
 
    bit::shared_ptr<int> sp3 = wp.lock();
    std::cout << sp3.use_count() << '\n';   // 3
}

这份实现只覆盖核心语义:构造、拷贝、移动、计数、lock。标准库还提供别名构造、自定义删除器、owner_before 等接口。课件用 int* 存计数,注释里写“改成 atomic<int>* 就能保证线程安全”,方向对;但只把计数放堆上还不够,weak_ptr 的 lock 需要强弱计数在同一块内存里,所以这里直接用控制块。

课件的 shared_ptr 拷贝赋值用 if (_ptr != sp._ptr) 判断自赋值。这里比较的是裸指针:两个用同一裸指针分别构造的 shared_ptr 拥有不同控制块,执行 a = b 时会被误判成自赋值,直接跳过,a 原来那份计数永远不释放。判断“是不是同一个所有者”应该比较控制块,不是 get() 返回的地址。

引用计数是原子的,对象不是

shared_ptr 的线程安全只在控制块这一层:多个线程各自持有一份 shared_ptr 副本,同时拷贝、析构、赋值,强计数和弱计数的加减不会丢。标准库的控制块计数用原子操作实现,自己手写就要用 std::atomic 或加锁。

上面那份实现为了篇幅,把 lock() 里的 expired() 检查和计数自增拆成了两步,单线程够用;多线程下这个窗口里最后一个强引用可能被放掉。标准实现做的是“计数非零时原子自增”,检查和自增合成一步。

被指向的对象完全不归 shared_ptr 管。两个线程通过各自副本改同一个对象,照样是数据竞争:

#include <atomic>
#include <memory>
#include <thread>
 
int main()
{
    std::shared_ptr<std::atomic<int>> sp = std::make_shared<std::atomic<int>>(0);
 
    auto work = [&sp]
    {
        for (int i = 0; i < 100000; ++i)
        {
            std::shared_ptr<std::atomic<int>> copy = sp;   // 计数原子
            ++*copy;                                        // 对象也是原子的
        }
    };
 
    std::thread t1(work);
    std::thread t2(work);
    t1.join();
    t2.join();
}

还有一层更隐蔽:同一个 shared_ptr 变量本身也不是线程安全的。sp = other 会同时改存储指针和控制块指针两个字段,两个线程直接对同一个变量赋值,即使计数原子也救不了。C++11 的解法是加锁;C++20 才有 std::atomic<std::shared_ptr<T>>,而且它原子化的是这个指针对象,不是它指向的 T。

内存泄漏:事前预防与事后检测

内存泄漏不是内存在物理上消失,而是程序失去了对一段已分配内存的控制。普通程序跑一会就结束,进程退出后页表映射解除,物理内存能回收;长期运行的服务、操作系统组件、客户端,泄漏会不断吃掉可用内存,响应越来越慢,最后卡死。

避免泄漏的路子分两类。事前预防:用智能指针管理资源,特殊资源按 RAII 自己包一层;申请和释放配对,异常路径也由析构函数兜住。事后查错:Linux 下用 Valgrind、AddressSanitizer 这类工具,Windows 下用 VLD 一类的第三方检测器,项目上线前跑一轮。工具不是万能的,有些要收费,有些对特定分配器支持不好,但比完全没有检测强。

选型就按所有权问两句话:谁负责释放,要不要共享。独占用 unique_ptr,共享用 shared_ptr,只观察用 weak_ptr 或裸引用。auto_ptr 已经不在标准里;shared_ptr 的计数原子只保护控制块;weak_ptr 不延长生命周期,访问前必须 lock。把这四条记住,智能指针的坑就剩下“别用裸指针构造第二个控制块”这一类细节。