智能指针总结

精选原创

贺实强的技术博客 2025-03-08 16:08:12 博主文章分类：C++ ©著作权

文章标签 shared_ptr 智能指针 C++ RAII 文章分类 C/C++ 后端开发 yyds干货盘点

©著作权归作者所有：来自51CTO博客作者贺实强的技术博客的原创作品，谢绝转载，否则将追究法律责任

1.什么是智能指针？

智能指针是 C++ 中用于管理动态分配内存的工具，通过封装原始指针并利用 RAII（资源获取即初始化）机制，自动管理对象的生命周期，避免内存泄漏和悬垂指针问题。智能指针是 C++11 引入的现代化特性，定义在 <memory> 头文件中。

2.C++为什么要引入智能指针？

自动管理内存
避免内存泄漏
支持复杂的所有权管理
避免悬空指针提高代码可维护性

3.智能指针的分类

auto_ptr ：管理权限转移，会导致被拷贝对象悬空，建议不要使用它

std::unique_ptr：

特性：独占所有权的智能指针，一个对象只能由一个 unique_ptr 管理，不能复制，只能移动（move）。
实现：通过移动语义（std::move）转移所有权。
析构：当 unique_ptr 超出作用域时，自动删除其管理的对象。

std::shared_ptr：

特性：共享所有权的智能指针，允许多个 shared_ptr 管理同一个对象，通过引用计数追踪使用情况。
实现：内部维护一个引用计数器，当最后一个 shared_ptr 被销毁时，释放对象。
开销：由于引用计数，性能开销略高于 unique_ptr。

std::weak_ptr：

特性：非拥有型的智能指针，用于解决 shared_ptr 的循环引用问题，不能直接访问对象。
实现：与 shared_ptr 配合使用，通过 lock() 方法获取 shared_ptr 来访问对象。
用途：打破循环引用，避免内存泄漏。

4.RAII机制优势

核心思想是将资源的管理与对象的生命周期绑定在一起。通过这一机制，C++ 能够实现自动的资源管理，避免了很多常见的错误，特别是在内存管理和资源释放方面。

5.智能指针常见使用场景

1. `std::unique_ptr`（独占式智能指针）

std::unique_ptr 是最常用的智能指针之一，它通过独占式的所有权管理动态分配的内存。意味着同一时间只有一个 unique_ptr 可以拥有某个资源。

常见使用场景：

动态对象的独占式所有权管理：当你希望一个对象在某个作用域内唯一拥有所有权并在离开作用域时自动释放内存时，std::unique_ptr 是理想的选择。
示例：

void foo() {
    std::unique_ptr<int> p(new int(10));  // 创建并分配内存
    // 使用 p
}  // 离开作用域时，p 会自动释放内存

避免内存泄漏：由于 std::unique_ptr 会在它超出作用域时自动释放资源，它是避免内存泄漏的一个重要工具。
实现资源管理： std::unique_ptr 适用于管理那些不需要共享资源的场景，比如一些局部的临时对象，或者不需要在多个地方共享的资源。

2. `std::shared_ptr`（共享式智能指针）

std::shared_ptr 是一种引用计数智能指针，允许多个 shared_ptr 实例共同管理同一个对象。只有当所有指向同一对象的 shared_ptr 都被销毁时，才会释放内存。

常见使用场景：

资源共享：当你需要多个对象共享对同一资源的所有权时，std::shared_ptr 是最适合的选择。例如，在多线程程序或者复杂的数据结构中，多个地方需要访问同一个对象时，shared_ptr 可以方便地处理共享所有权。
示例：

std::shared_ptr<int> p1 = std::make_shared<int>(20);
std::shared_ptr<int> p2 = p1;  // p2 共享 p1 所指向的对象

多线程场景：在多线程程序中，std::shared_ptr 可以帮助避免手动管理内存，从而减少因多线程引发的资源管理错误。
复杂的数据结构：在某些复杂的数据结构中（如树、图等），节点可能需要多个指针共享一个子节点，shared_ptr 是一种高效且安全的方式。

3. `std::weak_ptr`（弱引用智能指针）

std::weak_ptr 是一个用于观察 shared_ptr 管理对象的智能指针，它不会影响对象的引用计数。weak_ptr 适用于避免“循环引用”问题，避免因引用计数永不为零而导致内存泄漏。

常见使用场景：

避免循环引用：当两个对象互相持有 shared_ptr 时，会产生循环引用，导致内存无法释放。使用 std::weak_ptr 可以解决这个问题，它允许你“观察”一个由 shared_ptr 管理的对象，但不会增加其引用计数。
示例：

std::shared_ptr<Node> node1 = std::make_shared<Node>();
std::shared_ptr<Node> node2 = std::make_shared<Node>();
node1->next = node2;
node2->prev = node1;  // 如果 node1 和 node2 相互持有 shared_ptr，会造成循环引用

// 使用 weak_ptr 断开循环引用
node1->next = node2;
node2->prev = node1;
std::weak_ptr<Node> weakNode1 = node1;  // 使用 weak_ptr 避免循环引用

6.使用智能指针可以导致内存泄漏的场景

循环引用：需要使用 std::weak_ptr 解决。
错误的复制或传递智能指针：确保正确管理资源所有权。
std::unique_ptr 和 std::shared_ptr 的不当混用。
不当使用 std::weak_ptr 导致悬挂指针。
多线程环境中的竞态条件。

7. 智能指针与容器的配合使用

智能指针与 STL 容器（如 std::vector、std::map 等）结合使用时，需要特别注意所有权问题。在容器中存储智能指针时，容器会控制指针的生命周期，这通常不会造成内存泄漏，但如果容器中的元素被复制或移动，可能会导致一些细节问题。例如，std::shared_ptr 在多个容器之间共享时需要小心避免循环引用。

例子：

#include <memory>
#include <vector>

class MyClass {
public:
    void show() { std::cout << "Hello!" << std::endl; }
};

int main() {
    std::vector<std::shared_ptr<MyClass>> v;
    v.push_back(std::make_shared<MyClass>());
    
    // 使用 v[0] 时，智能指针会自动管理 MyClass 对象的生命周期
    v[0]->show();
}  // 离开作用域时，MyClass 的内存会被自动释放

8. 自定义删除器 (Custom Deleters)

智能指针（特别是 std::unique_ptr 和 std::shared_ptr）允许用户提供自定义的删除器（删除对象时使用的回调函数）。这在需要对对象释放时执行特殊操作（比如关闭文件、释放外部资源等）时非常有用。

例子：

#include <memory>
#include <iostream>

void customDeleter(int* ptr) {
    std::cout << "Deleting pointer: " << ptr << std::endl;
    delete ptr;
}

int main() {
    std::unique_ptr<int, decltype(&customDeleter)> ptr(new int(10), customDeleter);
    // 当 ptr 超出作用域时，customDeleter 会被调用
}

9. 智能指针与多态

智能指针支持多态性，在使用智能指针管理继承结构时（如基类指针指向派生类对象），其行为和普通指针一样，能够自动释放资源。这使得在面向对象编程中，智能指针非常有用。

例子：

#include <memory>
#include <iostream>

class Base {
public:
    virtual void show() { std::cout << "Base class" << std::endl; }
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived class" << std::endl; }
};

int main() {
    std::unique_ptr<Base> ptr = std::make_unique<Derived>();
    ptr->show();  // 调用 Derived 类的 show 方法
}  // 离开作用域时，Derived 类对象会被自动销毁

10. 智能指针的线程安全性

std::unique_ptr 是 不可复制 的，因此在多线程环境中使用时，通常会由一个线程拥有并管理。
std::shared_ptr 是 线程安全的，引用计数的操作是原子性的，因此可以在多个线程中共享。但是，多个线程操作同一个对象的内容时，仍然需要开发者自己处理线程同步问题，可以通过加锁等方式来解决同步问题。