C++ 智能指针详解：shared_ptr, auto_ptr 和 weak_ptr

字数统计: 3.2k字   |   阅读时长≈ 14分

C++ 智能指针详解：shared_ptr, auto_ptr 和 weak_ptr

1. shared_ptr：共享所有权智能指针

1.1 核心概念与定义

1.1.1 什么是 shared_ptr

std::shared_ptr 是 C++11 引入的共享所有权智能指针，它通过引用计数（Reference Counting） 机制实现多个智能指针共享同一个对象的所有权。与 unique_ptr 的独占所有权不同，shared_ptr 允许多个指针实例共同管理同一个动态分配的对象。

=、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
当最后一个指向对象的 shared_ptr 被销毁或重置时，对象才会被自动删除。这种机制使得 shared_ptr 在需要共享资源的场景下非常有用。

1.1.2 共享所有权语义

shared_ptr 的核心是共享所有权模型。多个 shared_ptr 实例可以指向同一个对象，它们通过内部的引用计数器来跟踪有多少个 shared_ptr 正在共享该对象。

1
2
3
4
std::shared_ptr<int> ptr1(new int(42));
std::shared_ptr<int> ptr2 = ptr1; // 引用计数变为 2
std::shared_ptr<int> ptr3 = ptr2; // 引用计数变为 3
// 当 ptr1, ptr2, ptr3 都被销毁时，对象才会被删除

1.1.3 引用计数机制

引用计数是 shared_ptr 的核心实现机制：

  • 当新的 shared_ptr 指向现有对象时，引用计数增加
  • 当 shared_ptr 被销毁或指向新对象时，引用计数减少
  • 当引用计数降为 0 时，对象被自动删除

1.2 内部实现与控制块

1.2.1 控制块（Control Block）结构

shared_ptr 的内部实现比 unique_ptr 复杂，它包含两个指针：

  1. 指向管理对象的指针
  2. 指向控制块的指针

控制块包含：

  • 引用计数器（use count）
  • 弱引用计数器（weak count）
  • 删除器（deleter）
  • 分配器（allocator）
1
2
3
4
5
6
7
template<typename T>
struct control_block {
    std::atomic<long> use_count;
    std::atomic<long> weak_count;
    void(*deleter)(T*);
    T* managed_object;
};

1.2.2 引用计数的原子操作

为了保证线程安全，shared_ptr 的引用计数操作必须是原子的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 近似实现
void increment_ref_count() {
    use_count.fetch_add(1, std::memory_order_relaxed);
}

void decrement_ref_count() {
    if (use_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
        // 最后一个 shared_ptr，删除对象
        deleter(managed_object);
        // 如果 weak_count 也为 0，删除控制块
        if (weak_count.load() == 0) {
            delete this;
        }
    }
}

1.3 常用接口与用法

1.3.1 构造与析构

1
2
3
4
5
6
7
8
9
10
11
// 多种构造方式
std::shared_ptr<int> p1(new int(42));
std::shared_ptr<int> p2 = std::make_shared<int>(42); // 推荐方式
std::shared_ptr<int> p3 = p1; // 拷贝构造，引用计数+1

// 自定义删除器
auto deleter = [](int* p) { 
    std::cout << "Deleting int\n"; 
    delete p; 
};
std::shared_ptr<int> p4(new int(42), deleter);

1.3.2 所有权管理接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();

// 获取原始指针（不增加引用计数）
MyClass* raw_ptr = ptr.get();

// 重置指针
ptr.reset(new MyClass()); // 原对象引用计数-1，管理新对象
ptr.reset(); // 变为空指针

// 交换两个 shared_ptr
std::shared_ptr<MyClass> ptr2 = std::make_shared<MyClass>();
ptr.swap(ptr2);

// 获取引用计数
long count = ptr.use_count(); // 注意：多线程环境下仅供参考

1.3.3 操作符重载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();

// 解引用操作
(*ptr).member_function();
ptr->member_function();

// 布尔转换
if (ptr) {
    // ptr 不为空
}

// 比较操作
if (ptr == ptr2) {
    // 指向同一对象
}

1.4 性能特点与开销

1.4.1 内存开销

  • 控制块开销：每个被管理的对象都有一个控制块
  • 指针开销：shared_ptr 本身包含两个指针（对象指针和控制块指针）
  • 总大小：通常是原始指针的两倍大小

1.4.2 运行时开销

  • 原子操作：引用计数的增减需要原子操作，有性能开销
  • 控制块分配：需要额外的内存分配（除非使用 make_shared）

1.4.3 make_shared 的优势

1
2
3
4
5
// 传统方式：两次内存分配（对象 + 控制块）
std::shared_ptr<MyClass> p1(new MyClass());

// make_shared：一次内存分配（对象和控制块在一起）
std::shared_ptr<MyClass> p2 = std::make_shared<MyClass>();

make_shared 将对象和控制块分配在连续内存中，提高了缓存局部性并减少了一次内存分配。

1.5 实际应用场景

1.5.1 共享资源管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Resource {
public:
    void use() { std::cout << "Using resource\n"; }
};

class User {
private:
    std::shared_ptr<Resource> resource_;
public:
    User(std::shared_ptr<Resource> res) : resource_(res) {}
    void doWork() { resource_->use(); }
};

// 多个用户共享同一资源
auto resource = std::make_shared<Resource>();
User user1(resource);
User user2(resource); // 共享同一资源

1.5.2 缓存系统

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Cache {
private:
    std::unordered_map<std::string, std::shared_ptr<Data>> cache_;
public:
    std::shared_ptr<Data> get(const std::string& key) {
        auto it = cache_.find(key);
        if (it != cache_.end()) {
            return it->second; // 返回共享指针，延长生命周期
        }
        return nullptr;
    }
    
    void put(const std::string& key, std::shared_ptr<Data> data) {
        cache_[key] = data;
    }
};

2. weak_ptr：弱引用智能指针

2.1 核心概念与定义

2.1.1 什么是 weak_ptr

std::weak_ptr 是一种不控制对象生命周期的智能指针，它是对由 shared_ptr 管理的对象的弱引用。weak_ptr 不会增加对象的引用计数，因此不会阻止对象的销毁。

2.1.2 弱引用语义

weak_ptr 的主要用途是打破 shared_ptr 的循环引用问题。它允许观察一个对象而不影响其生命周期。

1
2
3
4
5
6
7
8
std::shared_ptr<MyClass> shared = std::make_shared<MyClass>();
std::weak_ptr<MyClass> weak = shared; // 不增加引用计数

// 对象可能已被销毁，需要检查
if (auto locked = weak.lock()) {
    // 对象还存在，可以安全使用
    locked->doSomething();
}

2.2 内部实现机制

2.2.1 与控制块的交互

weak_ptr 内部也包含指向控制块的指针，但它只操作弱引用计数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
template<typename T>
class weak_ptr {
private:
    T* ptr_;
    control_block* cb_;
    
public:
    // 构造时增加弱引用计数
    weak_ptr(const shared_ptr<T>& other) : ptr_(other.ptr_), cb_(other.cb_) {
        if (cb_) cb_->weak_count.fetch_add(1);
    }
    
    // 析构时减少弱引用计数
    ~weak_ptr() {
        if (cb_) {
            if (cb_->weak_count.fetch_sub(1) == 1) {
                // 弱引用计数为0，但强引用计数可能不为0
                if (cb_->use_count.load() == 0) {
                    delete cb_; // 强引用和弱引用都为0，删除控制块
                }
            }
        }
    }
};

2.3 常用接口与用法

2.3.1 基本操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
std::shared_ptr<MyClass> shared = std::make_shared<MyClass>();
std::weak_ptr<MyClass> weak = shared;

// 检查对象是否还存在
if (!weak.expired()) {
    // 尝试获取 shared_ptr
    if (auto locked = weak.lock()) {
        locked->doSomething();
    }
}

// 直接获取 shared_ptr（如果对象已销毁则返回空）
std::shared_ptr<MyClass> locked = weak.lock();
if (locked) {
    // 安全使用
}

2.3.2 解决循环引用问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Node {
public:
    std::string name;
    // 使用 weak_ptr 避免循环引用
    std::weak_ptr<Node> parent;
    std::vector<std::shared_ptr<Node>> children;
    
    Node(const std::string& n) : name(n) {}
    
    void addChild(std::shared_ptr<Node> child) {
        children.push_back(child);
        child->parent = weak_from_this(); // C++17 新增
    }
};

auto node1 = std::make_shared<Node>("parent");
auto node2 = std::make_shared<Node>("child");
node1->addChild(node2); // 不会造成循环引用

2.4 实际应用场景

2.4.1 观察者模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Subject;

class Observer {
public:
    virtual void update(std::weak_ptr<Subject> subject) = 0;
    virtual ~Observer() = default;
};

class Subject {
private:
    std::vector<std::weak_ptr<Observer>> observers_;
public:
    void attach(std::weak_ptr<Observer> observer) {
        observers_.push_back(observer);
    }
    
    void notify() {
        for (auto it = observers_.begin(); it != observers_.end();) {
            if (auto observer = it->lock()) {
                observer->update(weak_from_this());
                ++it;
            } else {
                // 观察者已被销毁，移除
                it = observers_.erase(it);
            }
        }
    }
};

2.4.2 缓存系统优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class CacheWithWeakPtr {
private:
    std::unordered_map<std::string, std::weak_ptr<Data>> cache_;
    mutable std::mutex mutex_;
    
public:
    std::shared_ptr<Data> get(const std::string& key) {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = cache_.find(key);
        if (it != cache_.end()) {
            if (auto data = it->second.lock()) {
                return data; // 对象还存在
            } else {
                cache_.erase(it); // 对象已被销毁，清理缓存
            }
        }
        return nullptr;
    }
};

3. auto_ptr：已废弃的智能指针

3.1 历史背景与设计缺陷

3.1.1 auto_ptr 的起源

std::auto_ptr 是 C++98 标准中引入的第一个智能指针，旨在提供基本的自动内存管理功能。它在当时是一个重要的创新，但后来被发现存在严重的设计缺陷。

3.1.2 主要设计缺陷

  1. 有问题的拷贝语义：auto_ptr 的拷贝操作会转移所有权
  2. 不适用于标准库容器：由于非常规的拷贝语义，不能安全地在 STL 容器中使用
  3. 缺乏移动语义支持：在 C++11 之前，没有移动语义，导致 awkward 的所有权转移

3.2 问题示例与缺陷分析

3.2.1 危险的所有权转移

1
2
3
4
5
6
7
8
// C++98/03 中的 auto_ptr（已废弃）
std::auto_ptr<int> p1(new int(42));
std::auto_ptr<int> p2 = p1; // p1 变为空，所有权转移到 p2

// 意外行为：p1 现在为空，但代码可能继续使用它
if (p1.get()) { // 这个条件为 false
    *p1 = 100; // 未定义行为！
}

3.2.2 与 STL 容器的不兼容

1
2
3
4
5
6
7
8
9
std::vector<std::auto_ptr<int>> vec; // 危险的用法！

std::auto_ptr<int> p(new int(42));
vec.push_back(p); // p 的所有权转移到 vector 中

// 现在 p 为空，但代码可能不知道
if (p.get()) { // false
    // 永远不会执行
}

3.3 从 auto_ptr 到 unique_ptr 的演进

3.3.1 为什么 unique_ptr 更好

1
2
3
4
5
6
7
8
// unique_ptr 的明确语义
std::unique_ptr<int> p1(new int(42));
// std::unique_ptr<int> p2 = p1; // 编译错误！防止意外拷贝
std::unique_ptr<int> p2 = std::move(p1); // 明确的移动语义

// 可以安全地在容器中使用
std::vector<std::unique_ptr<int>> vec;
vec.push_back(std::make_unique<int>(42)); // 必须显式移动

3.3.2 迁移指南

如果遇到旧的 auto_ptr 代码，应该迁移到 unique_ptr：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 旧的 auto_ptr 代码
std::auto_ptr<MyClass> old_ptr(new MyClass());

// 迁移到 unique_ptr
std::unique_ptr<MyClass> new_ptr(new MyClass());

// 对于函数参数和返回值
std::auto_ptr<MyClass> create_old() {
    return std::auto_ptr<MyClass>(new MyClass());
}

std::unique_ptr<MyClass> create_new() {
    return std::make_unique<MyClass>();
}

3.4 现代替代方案总结

特性 auto_ptr (已废弃) unique_ptr shared_ptr weak_ptr
所有权模型 转移所有权 独占所有权 共享所有权 弱引用
拷贝语义 转移所有权（危险） 禁止拷贝 共享所有权 不增加引用计数
移动语义 无（C++98） 支持移动 支持移动 支持移动
容器兼容性 不兼容 兼容（需移动） 兼容 兼容
线程安全 无 无（但可单独保护） 引用计数原子操作 原子操作
推荐使用 不应使用 独占资源 共享资源 打破循环引用

4. 智能指针的最佳实践与陷阱

4.1 选择正确的智能指针

4.1.1 决策流程

  1. 是否需要共享所有权？

    • 否 → 使用 unique_ptr
    • 是 → 使用 shared_ptr

  2. 是否需要观察而不拥有？

    • 是 → 配合使用 weak_ptr

  3. 是否有循环引用风险？

    • 是 → 使用 weak_ptr 打破循环

4.1.2 使用场景总结

1
2
3
4
5
6
7
8
9
10
11
// 1. 独占资源 - unique_ptr
std::unique_ptr<File> file = openFile("data.txt");

// 2. 共享资源 - shared_ptr
std::shared_ptr<Database> db = std::make_shared<Database>();
auto user1 = User(db);
auto user2 = User(db); // 共享数据库连接

// 3. 观察资源 - weak_ptr
std::shared_ptr<Subject> subject = std::make_shared<Subject>();
std::weak_ptr<Subject> observer = subject;

4.2 常见陷阱与解决方案

4.2.1 循环引用问题

1
2
3
4
5
6
7
8
9
10
11
// 错误示例：循环引用导致内存泄漏
class BadNode {
    std::shared_ptr<BadNode> parent; // 应该使用 weak_ptr
    std::shared_ptr<BadNode> child;
};

// 正确解决方案
class GoodNode {
    std::weak_ptr<GoodNode> parent; // 使用 weak_ptr 打破循环
    std::shared_ptr<GoodNode> child;
};

4.2.2 避免原始指针与智能指针混用

1
2
3
4
5
6
7
8
// 危险的做法
MyClass* raw_ptr = new MyClass();
std::shared_ptr<MyClass> ptr1(raw_ptr);
// std::shared_ptr<MyClass> ptr2(raw_ptr); // 灾难！双重删除

// 安全的做法
std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
std::shared_ptr<MyClass> ptr2 = ptr1; // 共享所有权

4.2.3 this 指针问题

1
2
3
4
5
6
7
8
9
10
11
12
13
class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    std::shared_ptr<MyClass> get_shared() {
        return shared_from_this(); // 安全地获取 shared_ptr
    }
};

// 错误：直接从 this 创建 shared_ptr
// std::shared_ptr<MyClass> bad_ptr(this);

// 正确：使用 enable_shared_from_this
auto obj = std::make_shared<MyClass>();
auto good_ptr = obj->get_shared();

4.3 性能优化建议

4.3.1 优先使用 make_shared 和 make_unique

1
2
3
4
5
6
// 不推荐：两次内存分配
std::shared_ptr<MyClass> p1(new MyClass());

// 推荐：一次内存分配，更好的性能
std::shared_ptr<MyClass> p2 = std::make_shared<MyClass>();
std::unique_ptr<MyClass> p3 = std::make_unique<MyClass>();

4.3.2 避免不必要的 shared_ptr 拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 不好的做法：不必要的拷贝
void process(const std::shared_ptr<Data>& data) {
    // 如果不需要共享所有权，应该传引用
    data->process();
}

// 更好的做法：根据需求选择参数类型
void process_by_ref(Data& data) { // 不需要所有权
    data.process();
}

void process_by_shared(std::shared_ptr<Data> data) { // 需要共享所有权
    data->process();
}

通过理解和正确应用这些智能指针，可以编写出更安全、更高效的 C++ 代码，避免常见的内存管理错误。

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

僕は新世界の神となる!