智能指针

智能指针是现代 C++ 资源管理的核心工具。它们通过 RAII 原则自动管理动态分配的内存,消除了手动 new/delete 带来的各种隐患。本节将深入讲解三种智能指针——unique_ptr、shared_ptr、weak_ptr——的语义、使用场景和最佳实践。

为什么需要智能指针

手动管理动态内存是 C++ 中最常见的错误来源之一。考虑以下代码:

void process_data() {
    auto* data = new std::vector<int>(1000);

    // ... 做一些处理 ...

    if (has_error()) {
        return;  // 糟糕!内存泄漏!忘了 delete
    }

    // ... 更多处理 ...

    delete data;  // 只有正常路径才会到达这里
}

手动管理内存面临三大致命问题:

  • 内存泄漏(Memory Leak)——忘记 delete,或异常/提前返回绕过了 delete
  • 重复释放(Double Free)——对同一指针调用两次 delete,导致未定义行为
  • 悬空指针(Use-After-Free)——释放后继续使用指针,访问已回收的内存
// 重复释放
int* p = new int(42);
int* q = p;       // q 和 p 指向同一块内存
delete p;
delete q;         // 未定义行为!已经释放过了

// 悬空指针
int* ptr = new int(10);
delete ptr;
std::cout << *ptr;  // 未定义行为!访问已释放内存

核心理念:智能指针将"何时释放"的决策编码到类型系统中。编译器和对象生命周期规则自动保证正确释放,程序员不再需要手动追踪。

现代 C++ 提供三种智能指针(均定义在 <memory> 头文件中):

  • std::unique_ptr——唯一所有权,零开销
  • std::shared_ptr——共享所有权,引用计数
  • std::weak_ptr——非拥有观察者,配合 shared_ptr 使用

std::unique_ptr — 唯一所有权

std::unique_ptr 是最轻量、最常用的智能指针。它表达"只有我拥有这个对象"的语义,在离开作用域时自动删除所管理的对象。

基本用法

#include <memory>
#include <iostream>

struct Widget {
    int id;
    Widget(int i) : id(i) { std::cout << "Widget " << id << " 创建\n"; }
    ~Widget()             { std::cout << "Widget " << id << " 销毁\n"; }
};

int main() {
    // 使用 make_unique 创建(推荐)
    auto w = std::make_unique<Widget>(1);

    std::cout << "Widget id = " << w->id << "\n";

    // 像普通指针一样使用
    Widget& ref = *w;        // 解引用
    Widget* raw = w.get();   // 获取裸指针(不转移所有权)

    // 离开作用域时自动销毁
}
// 输出:
// Widget 1 创建
// Widget id = 1
// Widget 1 销毁

不可复制,只能移动

unique_ptr 禁止拷贝——因为"唯一所有权"意味着不能有两个指针同时拥有同一对象。但可以通过 std::move 转移所有权:

auto a = std::make_unique<Widget>(42);

// auto b = a;           // 编译错误!不可拷贝
auto b = std::move(a);   // OK:所有权从 a 转移到 b

// 移动后 a 变成空指针
if (!a) {
    std::cout << "a 已经为空\n";
}
std::cout << "b->id = " << b->id << "\n";  // 42

作为函数返回值(工厂模式)

返回 unique_ptr 是表达"函数创建了一个对象,调用者拥有它"的标准惯用法:

// 工厂函数:创建对象并返回所有权
std::unique_ptr<Widget> create_widget(int id) {
    auto w = std::make_unique<Widget>(id);
    // ... 初始化设置 ...
    return w;  // 自动移动,无需 std::move
}

void caller() {
    auto my_widget = create_widget(7);
    // my_widget 拥有这个 Widget,离开作用域时自动释放
}

自定义删除器

默认情况下 unique_ptr 使用 delete 释放资源。但有时我们管理的不是 new 出来的内存——比如 C 语言风格的资源:

#include <cstdio>
#include <memory>

// 管理 FILE*:用 fclose 作为删除器
auto file = std::unique_ptr<FILE, decltype(&std::fclose)>(
    std::fopen("data.txt", "r"),
    &std::fclose
);

if (file) {
    char buf[256];
    while (std::fgets(buf, sizeof(buf), file.get())) {
        // 处理每一行
    }
}
// 离开作用域时自动调用 fclose

数组特化

// unique_ptr 的数组特化版本
auto arr = std::make_unique<int[]>(100);  // 分配 100 个 int

arr[0] = 42;
arr[99] = 7;

// 自动调用 delete[] 释放
// 注意:通常优先使用 std::vector,除非需要固定大小的动态数组

性能提示:unique_ptr 是零开销抽象。在大多数实现中,sizeof(unique_ptr<T>) == sizeof(T*),与裸指针完全相同的内存布局和运行时开销。

std::shared_ptr — 共享所有权

当多个对象需要共同拥有一个资源时,使用 std::shared_ptr。它内部维护一个引用计数——每增加一个共享者计数加一,每销毁一个共享者计数减一,归零时释放资源。

基本用法

#include <memory>
#include <iostream>

struct Connection {
    std::string name;
    Connection(std::string n) : name(std::move(n)) {
        std::cout << "连接 [" << name << "] 打开\n";
    }
    ~Connection() {
        std::cout << "连接 [" << name << "] 关闭\n";
    }
};

int main() {
    // 使用 make_shared 创建(推荐)
    auto conn = std::make_shared<Connection>("数据库");

    std::cout << "引用计数: " << conn.use_count() << "\n";  // 1

    {
        auto conn2 = conn;  // 拷贝:引用计数变为 2
        std::cout << "引用计数: " << conn.use_count() << "\n";  // 2

        auto conn3 = conn;  // 再拷贝:引用计数变为 3
        std::cout << "引用计数: " << conn.use_count() << "\n";  // 3
    }
    // conn2 和 conn3 离开作用域,引用计数回到 1

    std::cout << "引用计数: " << conn.use_count() << "\n";  // 1
}
// conn 离开作用域,引用计数归零,Connection 被销毁
// 输出最后一行:连接 [数据库] 关闭

引用计数的开销

shared_ptr 并非"免费的午餐"。相比 unique_ptr,它带来额外开销:

  • 控制块(Control Block)——每个 shared_ptr 管理的对象都有一个控制块,包含强引用计数、弱引用计数和删除器
  • 原子操作——引用计数的增减是原子操作(线程安全),比普通自增/自减更慢
  • 内存占用——sizeof(shared_ptr<T>) 通常是两个指针大小(一个指向对象,一个指向控制块)
// shared_ptr 的内存布局示意
//
// shared_ptr<Widget> sp:
//   ┌──────────────┐
//   │ 对象指针 ptr  │──────→ [ Widget 对象 ]
//   │ 控制块指针    │──┐
//   └──────────────┘  │
//                     ▼
//              ┌─────────────┐
//              │ 强引用计数: 2 │
//              │ 弱引用计数: 1 │
//              │ 删除器       │
//              │ 分配器       │
//              └─────────────┘

注意:use_count() 仅用于调试和日志输出。在多线程环境中,读取 use_count() 的结果可能立即过时。不要基于 use_count() 的值做业务逻辑判断。

何时使用 shared_ptr

只在"真正的共享所有权"场景使用 shared_ptr:

// 场景:多个窗口共享同一个文档对象
class Document {
public:
    std::string content;
    void save() { /* ... */ }
};

class EditorWindow {
    std::shared_ptr<Document> doc_;  // 共享文档所有权
public:
    EditorWindow(std::shared_ptr<Document> doc) : doc_(std::move(doc)) {}

    void edit(std::string_view text) {
        doc_->content += text;
    }
};

// 两个窗口编辑同一个文档
auto doc = std::make_shared<Document>();
EditorWindow window1(doc);
EditorWindow window2(doc);
// 关闭任一窗口不会销毁文档;只有所有窗口都关闭时文档才被释放

std::weak_ptr — 打破循环引用

std::weak_ptr 是 shared_ptr 的"非拥有观察者"。它指向一个由 shared_ptr 管理的对象,但不增加引用计数。这解决了循环引用导致内存泄漏的问题。

循环引用问题

// 错误示范:循环引用导致永远无法释放
struct Node {
    std::string name;
    std::shared_ptr<Node> next;  // 强引用
    std::shared_ptr<Node> prev;  // 强引用 → 循环!

    ~Node() { std::cout << name << " 被销毁\n"; }
};

void leak_example() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->name = "A";
    b->name = "B";

    a->next = b;   // A → B(引用计数 B=2)
    b->prev = a;   // B → A(引用计数 A=2)
}
// 函数结束:局部变量 a, b 销毁
// A 的引用计数从 2 降到 1(B 还持有)
// B 的引用计数从 2 降到 1(A 还持有)
// 两者都不会归零 → 永远不会释放!内存泄漏!

用 weak_ptr 解决

// 正确:用 weak_ptr 打破循环
struct Node {
    std::string name;
    std::shared_ptr<Node> next;   // 前向用强引用
    std::weak_ptr<Node> prev;     // 后向用弱引用,不增加计数

    ~Node() { std::cout << name << " 被销毁\n"; }
};

void no_leak() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->name = "A";
    b->name = "B";

    a->next = b;   // A → B(引用计数 B=2)
    b->prev = a;   // B → A(弱引用,A 的引用计数仍为 1)
}
// 函数结束:
// a 销毁 → A 引用计数归零 → A 被释放 → A 持有的 next(B) 释放
// → B 引用计数归零 → B 被释放
// 输出:A 被销毁 \n B 被销毁

weak_ptr 的使用方式

auto shared = std::make_shared<Widget>(42);
std::weak_ptr<Widget> weak = shared;  // 从 shared_ptr 创建 weak_ptr

// 使用前必须 lock(),获得一个临时的 shared_ptr
if (auto locked = weak.lock()) {
    // locked 不为空,对象仍然存活
    std::cout << "Widget id = " << locked->id << "\n";
} else {
    // 对象已被释放
    std::cout << "对象已不存在\n";
}

// 也可以用 expired() 检查(但存在 TOCTOU 竞争)
if (!weak.expired()) {
    // 注意:在多线程中,到这里时对象可能已经被释放了
    // 所以实际使用时还是应该用 lock()
}

观察者/缓存模式

// 缓存模式:weak_ptr 允许对象在没有外部引用时被回收
class TextureCache {
    std::unordered_map<std::string, std::weak_ptr<Texture>> cache_;

public:
    std::shared_ptr<Texture> get_texture(const std::string& path) {
        // 尝试从缓存获取
        if (auto it = cache_.find(path); it != cache_.end()) {
            if (auto tex = it->second.lock()) {
                return tex;  // 缓存命中,对象仍存活
            }
            cache_.erase(it);  // 对象已被释放,清理缓存条目
        }

        // 加载新纹理
        auto tex = std::make_shared<Texture>(load_from_disk(path));
        cache_[path] = tex;  // 存入弱引用
        return tex;
    }
};

经验法则:在"拥有者-观察者"关系中,拥有者持有 shared_ptr,观察者持有 weak_ptr。典型场景包括:父子节点关系(子节点用 weak_ptr 指向父节点)、缓存、事件系统中的订阅者。

make_unique / make_shared

始终优先使用 std::make_unique 和 std::make_shared 而非直接 new。

异常安全性

// 危险:参数求值顺序未定义可能导致泄漏
void process(std::shared_ptr<Widget> w, int priority);

// C++14/17 中,以下调用可能泄漏:
process(std::shared_ptr<Widget>(new Widget()), compute_priority());
// 可能的求值顺序:
// 1. new Widget()          ← 分配内存
// 2. compute_priority()    ← 如果这里抛出异常...
// 3. shared_ptr 构造       ← 永远不会执行!Widget 泄漏!

// 安全写法:
process(std::make_shared<Widget>(), compute_priority());
// make_shared 内部一步完成分配和封装,不会泄漏

说明:C++17 规定了函数参数的求值限制,降低了上述风险,但使用 make 函数仍是最佳实践,因为它还有性能优势。

make_shared 的性能优势

// 使用 new:两次内存分配
auto sp = std::shared_ptr<Widget>(new Widget(42));
// 第 1 次分配:new Widget    → 对象内存
// 第 2 次分配:shared_ptr 内部 → 控制块内存

// 使用 make_shared:一次内存分配
auto sp = std::make_shared<Widget>(42);
// 一次分配:对象 + 控制块放在连续内存中
// 好处:减少一次 malloc,提高缓存局部性

不能使用 make_shared 的情况

// 1. 需要自定义删除器
auto file = std::shared_ptr<FILE>(
    std::fopen("log.txt", "w"),
    [](FILE* f) { if (f) std::fclose(f); }
);

// 2. weak_ptr 长期存在时,make_shared 会延迟释放对象内存
// 因为 make_shared 将对象和控制块分配在一起,
// 只要还有 weak_ptr 指向控制块,整块内存都不会释放
// 如果对象很大且 weak_ptr 生命周期很长,可能浪费内存

// 3. 已经有裸指针(来自遗留代码/C 库)
Widget* legacy_ptr = legacy_create_widget();
auto sp = std::shared_ptr<Widget>(legacy_ptr, legacy_destroy_widget);

所有权设计原则

选择函数参数类型时,传达的是所有权意图:

// ① 不关心所有权,只是"借用"观察
void print_widget(const Widget& w);       // 引用:非空保证
void maybe_use(const Widget* w);          // 裸指针:可能为 null

// ② 获取唯一所有权("吞掉"这个对象)
void take_ownership(std::unique_ptr<Widget> w);
// 调用者必须 std::move,明确表示"我不再拥有这个对象"

// ③ 共享所有权
void share_ownership(std::shared_ptr<Widget> w);
// 拷贝 shared_ptr,引用计数 +1

// ④ 可能延长生命周期(参与共享)
void might_keep(const std::shared_ptr<Widget>& w);
// 传 const 引用避免不必要的引用计数操作
// 如果需要保存,函数内部再拷贝

重要原则:默认使用 unique_ptr。只有当多个对象确实需要共同拥有一个资源、且无法确定谁最后使用完毕时,才升级为 shared_ptr。过度使用 shared_ptr 会模糊所有权关系,使代码难以理解。

Herb Sutter 的参数传递指南

参数类型 语义 使用场景
Widget* / Widget& 非拥有,只观察 函数不影响对象生命周期
unique_ptr<Widget> 转移唯一所有权 工厂输出、sink 函数
unique_ptr<Widget>& 可能重置/释放 函数可能修改指针本身
shared_ptr<Widget> 共享所有权 函数需要保留一份所有权
const shared_ptr<Widget>& 可能共享 函数可能保存也可能不保存

工厂模式与多态

智能指针与多态结合使用是现代 C++ 中非常常见的模式。unique_ptr<Base> 可以持有任何派生类对象:

#include <memory>
#include <iostream>
#include <numbers>

// 形状基类
class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;
    virtual std::string name() const = 0;
};

// 具体形状
class Circle : public Shape {
    double radius_;
public:
    explicit Circle(double r) : radius_(r) {}
    double area() const override { return std::numbers::pi * radius_ * radius_; }
    std::string name() const override { return "圆形"; }
};

class Rectangle : public Shape {
    double w_, h_;
public:
    Rectangle(double w, double h) : w_(w), h_(h) {}
    double area() const override { return w_ * h_; }
    std::string name() const override { return "矩形"; }
};

// 形状类型枚举
enum class ShapeType { Circle, Rectangle };

// 工厂函数:返回 unique_ptr<Shape>
std::unique_ptr<Shape> create_shape(ShapeType type) {
    switch (type) {
        case ShapeType::Circle:
            return std::make_unique<Circle>(5.0);
        case ShapeType::Rectangle:
            return std::make_unique<Rectangle>(3.0, 4.0);
    }
    return nullptr;  // 不可达,但防止编译警告
}

int main() {
    // 工厂创建不同类型的形状
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(create_shape(ShapeType::Circle));
    shapes.push_back(create_shape(ShapeType::Rectangle));

    for (const auto& shape : shapes) {
        std::cout << shape->name() << " 的面积: "
                  << shape->area() << "\n";
    }
}
// 输出:
// 圆形 的面积: 78.5398
// 矩形 的面积: 12

关键点:基类必须有 virtual 析构函数(或使用 = default)。否则通过基类指针删除派生类对象是未定义行为。unique_ptr<Base> 在销毁时会正确调用派生类的析构函数。

unique_ptr 转换为 shared_ptr

// unique_ptr 可以隐式转换为 shared_ptr(但反过来不行)
std::unique_ptr<Shape> shape = create_shape(ShapeType::Circle);

// 工厂返回 unique_ptr,但调用者决定要共享所有权
std::shared_ptr<Shape> shared_shape = std::move(shape);
// 此时 shape 为空,shared_shape 拥有对象

本节小结

  • unique_ptr 是默认选择——零开销、唯一所有权、不可拷贝只可移动
  • shared_ptr 用于真正的共享所有权——引用计数管理生命周期,有额外开销
  • weak_ptr 打破循环引用——非拥有观察者,使用前需 lock()
  • 始终使用 make_unique / make_shared——异常安全、性能更优
  • 函数参数类型传达所有权意图——裸指针/引用表示借用,smart pointer 表示所有权转移或共享
  • 工厂模式返回 unique_ptr<Base>——调用者可根据需要转换为 shared_ptr