C++11的智能指针有哪些类型 shared_ptr unique_ptr使用场景分析

c++++11引入智能指针的核心目的是解决传统手动内存管理带来的内存泄漏、野指针、重复释放等问题，并通过raii机制实现资源的自动管理和释放。1. 内存泄漏：智能指针将资源生命周期绑定到对象生命周期，离开作用域后自动释放资源；2. 野指针：智能指针在销毁时自动置空内部原始指针，防止误用悬空指针；3. 重复释放：unique_ptr通过独占所有权避免重复释放，shared_ptr通过引用计数确保资源只被释放一次；4. 异常安全：栈上智能指针无论函数正常返回或异常退出都会被销毁，保证资源释放；5. 提升代码可读性和维护性：封装内存管理逻辑，使代码更简洁清晰。

C++11引入的智能指针主要有

std::unique_ptr

std::shared_ptr

new

delete

解决方案

在我看来，C++11的智能指针是现代C++编程中不可或缺的一部分，它们彻底改变了我们处理动态内存的方式。理解

unique_ptr

shared_ptr

std::unique_ptr

立即学习“C++免费学习笔记（深入）”；

unique_ptr

unique_ptr

unique_ptr

• 核心特性：

  • 独占性： 不可复制，只能通过移动语义（

    std::move

    ）转移所有权。这确保了内存资源永远只有一个明确的拥有者。
  • 轻量级： 几乎没有额外的开销，其大小通常与原始指针相同。它不涉及引用计数，因此性能开销非常小。
  • 默认删除器： 默认使用

    delete

    操作符来释放内存，但你可以自定义删除器，这在管理文件句柄、网络连接等非内存资源时非常有用。

• 使用场景：

  • 当你确定一个对象只有一个所有者，并且该所有者负责对象的生命周期时，

    unique_ptr

    是最佳选择。
  • 局部变量： 函数内部创建的动态对象，在函数结束时自动释放。
  • 容器元素：

    std::vector>

    可以存储多个独立拥有所有权的T类型对象。
  • 工厂函数返回类型： 当一个工厂函数创建并返回一个新对象时，通常应该返回

    unique_ptr

    ，让调用者获得该对象的独占所有权。
  • PIMPL（Pointer to Implementation）模式： 隐藏实现细节，减少头文件依赖。

• 示例：

  #include 
  #include 
  
  class MyObject {
  public:
      MyObject() { std::cout << "MyObject constructed!\n"; }
      ~MyObject() { std::cout << "MyObject destroyed!\n"; }
      void doSomething() { std::cout << "Doing something...\n"; }
  };
  
  // 工厂函数返回unique_ptr
  std::unique_ptr createObject() {
      return std::make_unique(); // 推荐使用make_unique
  }
  
  void processObject(std::unique_ptr obj) {
      if (obj) {
          obj->doSomething();
      }
      // obj超出作用域时自动销毁MyObject
  }
  
  int main() {
      auto p1 = createObject(); // p1拥有MyObject
      p1->doSomething();
  
      auto p2 = std::move(p1); // 所有权从p1转移到p2，p1现在为空
      if (!p1) {
          std::cout << "p1 is now empty.\n";
      }
      p2->doSomething();
  
      processObject(std::move(p2)); // 所有权转移给函数参数，函数结束后销毁
      // p2现在为空
      return 0;
  }

std::shared_ptr

shared_ptr

shared_ptr

shared_ptr

• 核心特性：

  • 共享性： 可以被复制，每次复制都会增加引用计数。
  • 引用计数： 内部维护一个引用计数，记录有多少个

    shared_ptr

    指向同一个对象。当计数归零时，对象被删除。
  • 控制块：

    shared_ptr

    比

    unique_ptr

    稍微重一些，因为它需要一个额外的控制块来存储引用计数、弱引用计数（

    weak_ptr

    相关）以及自定义删除器等信息。
  • 线程安全： 引用计数的增减是原子操作，保证了多线程环境下的安全性，但对象本身的访问不是线程安全的。

• 使用场景：

  • 当多个对象需要共享同一个资源，并且这个资源的生命周期需要由所有共享者共同决定时，

    shared_ptr

    是理想选择。
  • 缓存机制： 缓存中的数据可能被多个客户端访问，只有当所有客户端都不再需要时才释放。
  • 对象图/树结构： 当节点之间存在复杂的相互引用，但又不想陷入循环引用时（需要配合

    weak_ptr

    ）。
  • 多线程环境： 多个线程需要访问同一个对象，并确保对象在所有线程完成操作后才销毁。

• 示例：

  #include 
  #include 
  #include 
  
  class Resource {
  public:
      Resource() { std::cout << "Resource acquired!\n"; }
      ~Resource() { std::cout << "Resource released!\n"; }
      void use() { std::cout << "Using resource.\n"; }
  };
  
  void consumer(std::shared_ptr res) {
      std::cout << "Consumer: current ref count = " << res.use_count() << "\n";
      res->use();
  } // res超出作用域，引用计数减一
  
  int main() {
      std::shared_ptr r1 = std::make_shared(); // 推荐使用make_shared
      std::cout << "r1 ref count = " << r1.use_count() << "\n"; // 1
  
      std::shared_ptr r2 = r1; // 复制，引用计数增加
      std::cout << "r1 ref count = " << r1.use_count() << "\n"; // 2
      std::cout << "r2 ref count = " << r2.use_count() << "\n"; // 2
  
      consumer(r1); // 传递副本，引用计数临时增加到3，函数返回后减回2
  
      std::vector> resources;
      resources.push_back(r1); // 引用计数增加到3
      std::cout << "r1 ref count after push_back = " << r1.use_count() << "\n"; // 3
  
      r1.reset(); // r1不再指向Resource，引用计数减一
      std::cout << "r1 is null: " << (r1 == nullptr) << "\n"; // true
      std::cout << "r2 ref count after r1 reset = " << r2.use_count() << "\n"; // 2
  
      // 当r2和resources中的shared_ptr都销毁时，Resource才会被释放
      return 0;
  }

为什么C++11引入智能指针？它们解决了哪些传统问题？

说实话，C++11引入智能指针，在我看来，是C++语言发展史上一个里程碑式的改进。在此之前，手动管理内存简直是“痛点”的代名词。我们得小心翼翼地配对

new

delete

delete

智能指针的出现，正是为了解决这些“老大难”问题：

• 内存泄漏： 这是最常见的，也是最让人头疼的问题。忘记

  delete

  ，或者在复杂的逻辑分支、异常处理中遗漏

  delete

  ，都会导致内存无法回收。智能指针通过RAII（Resource Acquisition Is Initialization，资源获取即初始化）原则，将资源的生命周期与对象的生命周期绑定。当智能指针对象被销毁时，它所管理的资源（比如堆内存）也会自动被释放。这就像是给你的动态内存资源买了一份“自动销毁”保险，省心。

• 野指针/悬空指针： 当一个对象被

  delete

  后，指向它的原始指针如果没有被置空，就成了野指针。后续如果误用这个野指针，就会导致不可预测的行为。智能指针在自身销毁时，会将其内部的原始指针置空（或在

  shared_ptr

  中通过引用计数管理），有效避免了这类问题。

• 重复释放（Double Free）： 对同一块内存进行两次

  delete

  操作，会导致程序崩溃。

  unique_ptr

  的独占性保证了资源不会被重复释放，而

  shared_ptr

  的引用计数机制也确保了资源只会在最后一个引用消失时被释放一次。

• 异常安全： 在没有智能指针的情况下，如果在函数执行过程中抛出异常，那么在异常点之后的

  delete

  语句可能永远不会被执行，从而导致内存泄漏。智能指针是栈上的对象，无论函数是正常返回还是通过抛出异常退出，栈上的对象都会被正确销毁，从而保证了资源的释放，极大地提升了代码的异常安全性。
  

  Q.AI视频生成工具

  支持一分钟生成专业级短视频，多种生成方式，AI视频脚本，在线云编辑，画面自由替换，热门配音媲美真人音色，更多强大功能尽在QAI

  下载

• 代码可读性和维护性： 显式的

  new

  和

  delete

  散落在代码各处，让代码变得冗长且难以理解。使用智能指针后，内存管理逻辑被封装起来，代码变得更简洁，也更容易理解其意图。

在我看来，智能指针不仅仅是语法糖，它们是C++内存管理哲学的一次深刻变革，让C++在保持高性能的同时，也能拥有接近GC语言的内存安全性。

unique_ptr

和

shared_ptr

在性能和内存开销上有何不同？我该如何选择？

这就像是给你的代码选工具，趁手不趁手，效率差很多。选择

unique_ptr

shared_ptr

unique_ptr

• 性能： 几乎没有运行时开销。它的操作（构造、析构、移动）与原始指针的操作效率相当。因为没有引用计数，所以不需要原子操作，在多线程环境下尤其体现出其轻量优势。
• 内存开销： 极低。一个

  unique_ptr

  对象的大小通常与一个原始指针相同（在64位系统上是8字节）。它不需要额外的控制块来存储引用计数或其他元数据。

shared_ptr

• 性能： 相对

  unique_ptr

  会有一些额外的运行时开销。主要体现在：
  • 引用计数操作： 每次复制、赋值或销毁

    shared_ptr

    时，都需要对引用计数进行原子增减操作。原子操作虽然比非原子操作慢，但为了线程安全，这是必要的。
  • 控制块管理：

    shared_ptr

    在内部维护一个“控制块”（control block），这个控制块包含了引用计数、弱引用计数、自定义删除器和分配器等信息。创建第一个

    shared_ptr

    时，需要额外分配这个控制块的内存。
• 内存开销： 较高。一个

  shared_ptr

  对象通常是原始指针的两倍大小（在64位系统上是16字节），因为它内部需要存储两个指针：一个指向实际对象，一个指向控制块。此外，每个

  shared_ptr

  管理的资源还会有一个额外的控制块内存开销。

如何选择？

我的建议是，优先使用

unique_ptr

shared_ptr

• 选择

  unique_ptr

  的情况：
  • 独占所有权是自然逻辑： 当一个资源只有一个明确的拥有者，并且该所有者负责其生命周期时。例如，一个函数内部创建的对象，或者一个类成员变量，其生命周期与类实例绑定。
  • 追求极致性能和最小内存： 在性能敏感的场景，或者内存受限的环境中，

    unique_ptr

    是更好的选择。
  • 作为工厂函数的返回类型： 当你希望函数创建并移交一个新对象的独占所有权时。
  • 作为容器元素：

    std::vector>

    可以有效地管理一组独立拥有的对象。

• 选择

  shared_ptr

  的情况：
  • 确实需要共享所有权： 当多个对象需要共同管理一个资源的生命周期，并且资源应该在所有引用者都放弃后才被释放时。例如，一个大型配置对象，被多个模块共享；或者一个缓存系统中的数据项，被多个客户端引用。
  • 对象生命周期复杂，难以预测： 在一些复杂的对象图或多线程环境中，如果难以确定哪个对象是资源的唯一所有者，

    shared_ptr

    可以简化管理。
  • 需要将对象传递给回调函数或异步任务： 确保对象在回调执行期间仍然存活。

总的来说，

unique_ptr

shared_ptr

使用智能指针时有哪些常见的陷阱和最佳实践？特别是关于循环引用和

weak_ptr

？

智能指针确实是现代C++的利器，但就像任何强大的工具一样，如果使用不当，也可能带来新的问题。我个人在项目里也踩过一些坑，其中最典型的就是

shared_ptr

常见的陷阱：

1. shared_ptr

   的循环引用（Circular References）： 这是

   shared_ptr

   最臭名昭著的陷阱。当两个或多个

   shared_ptr

   相互持有对方的

   shared_ptr

   时，就会形成循环。比如，对象A有一个

   shared_ptr

   指向B，同时对象B有一个

   shared_ptr

   指向A。在这种情况下，A和B的引用计数永远不会降为零，即使它们已经不再被外部引用，它们也永远不会被销毁，导致内存泄漏。

   • 示例：

     #include 
     #include 
     
     class B; // 前向声明
     
     class A {
     public:
         std::shared_ptr b_ptr;
         A() { std::cout << "A constructed!\n"; }
         ~A() { std::cout << "A destroyed!\n"; }
     };
     
     class B {
     public:
         std::shared_ptr a_ptr;
         B() { std::cout << "B constructed!\n"; }
         ~B() { std::cout << "B destroyed!\n"; }
     };
     
     void create_circular_ref() {
         auto a = std::make_shared();
         auto b = std::make_shared();
         a->b_ptr = b; // A持有B
         b->a_ptr = a; // B持有A，形成循环
         // 当a和b超出作用域时，它们的引用计数都是1，永远不会降为0，A和B都不会被销毁。
     } // 内存泄漏发生在这里
     
     int main() {
         create_circular_ref();
         std::cout << "Back in main, objects might have leaked if not handled.\n";
         return 0;
     }

2. 从原始指针创建多个

   shared_ptr

   ： 如果你有一个原始指针，然后用它创建了多个独立的

   shared_ptr

   ，而不是通过复制一个

   shared_ptr

   来创建，那么每个

   shared_ptr

   都会有自己的引用计数控制块。这会导致对象被多次释放，引发运行时错误。
   • 错误示例：

     int* raw_ptr = new int(10);
     std::shared_ptr s1(raw_ptr);
     std::shared_ptr s2(raw_ptr); // 危险！s1和s2会独立管理同一个raw_ptr，导致重复释放

3. 在构造函数中返回

   shared_ptr

   ： 直接在对象的构造函数中，通过

   shared_ptr(this)

   来获取当前对象的

   shared_ptr

   ，这是不安全的。因为

   this

   指针是一个原始指针，这样做会创建一个新的控制块，同样导致多重管理。

4. 混合使用原始指针和智能指针： 当一个资源同时被原始指针和智能指针管理时，很容易出错。智能指针可能在原始指针还在使用时就释放了资源，导致野指针。