C++中如何使用智能指针_智能指针使用指南与示例

智能指针通过自动内存管理解决c++++中手动管理内存导致的泄漏问题。1. unique_ptr实现独占所有权，不可复制但可移动，适合单一所有者场景；2. shared_ptr采用引用计数实现共享所有权，适用于多指针共享对象的情况，但需注意循环引用问题；3. weak_ptr作为弱引用不增加引用计数，用于打破shared_ptr之间的循环引用。此外，推荐使用make_unique和make_shared创建智能指针，以提高性能和异常安全性，同时避免与原始指针混合使用带来的双重释放、内存泄漏和悬挂指针等风险。

智能指针本质上是为了更好地管理C++中的内存，避免手动new和delete带来的内存泄漏问题。它们就像负责任的保姆，在你不再需要某个对象时自动释放它，让你从繁琐的内存管理中解放出来。

解决方案

C++提供了三种主要的智能指针：unique_ptr、shared_ptr和weak_ptr。选择哪种取决于你的具体需求和对象的所有权模型。

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

• unique_ptr：独占所有权

  

  unique_ptr代表独占所有权，也就是说，同一时间只能有一个unique_ptr指向某个对象。当unique_ptr销毁时，它所指向的对象也会被自动删除。这使得unique_ptr非常适合用于管理那些只需要单个所有者的情况，比如函数内部创建的对象。

  #include <iostream>
  #include <memory>
  
  class MyClass {
  public:
      MyClass() { std::cout << "MyClass created\n"; }
      ~MyClass() { std::cout << "MyClass destroyed\n"; }
  };
  
  int main() {
      std::unique_ptr<MyClass> ptr(new MyClass());
      // 或者使用 make_unique (C++14及以上)
      // auto ptr = std::make_unique<MyClass>();
  
      if (ptr) {
          std::cout << "unique_ptr is not null\n";
      }
  
      // 当ptr离开作用域时，MyClass对象会被自动销毁
      return 0;
  }

  登录后复制

  关键点：unique_ptr不能复制，但可以移动（使用std::move）。这意味着你可以将所有权从一个unique_ptr转移到另一个。

• shared_ptr：共享所有权

  shared_ptr允许多个智能指针指向同一个对象，它使用引用计数来跟踪有多少个shared_ptr指向该对象。当最后一个shared_ptr销毁时，对象才会被删除。这对于需要在多个地方共享对象所有权的情况非常有用。

  #include <iostream>
  #include <memory>
  
  class MyClass {
  public:
      MyClass() { std::cout << "MyClass created\n"; }
      ~MyClass() { std::cout << "MyClass destroyed\n"; }
  };
  
  int main() {
      std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
      std::shared_ptr<MyClass> ptr2 = ptr1; // ptr1和ptr2共享同一个对象
  
      std::cout << "Reference count: " << ptr1.use_count() << "\n"; // 输出 2
  
      ptr1.reset(); // ptr1不再指向对象，引用计数减1
      std::cout << "Reference count: " << ptr2.use_count() << "\n"; // 输出 1
  
      // 当ptr2离开作用域时，MyClass对象会被自动销毁
      return 0;
  }

  登录后复制

  注意：shared_ptr会带来一定的性能开销，因为需要维护引用计数。另外，循环引用会导致内存泄漏，需要使用weak_ptr来解决。

• weak_ptr：观察者

  weak_ptr是一种弱引用，它指向由shared_ptr管理的对象，但不增加引用计数。weak_ptr可以用来检查对象是否仍然存在，并且可以从weak_ptr创建一个shared_ptr来获取对象的所有权（如果对象仍然存在）。这对于打破循环引用非常有用。

  #include <iostream>
  #include <memory>
  
  class B; // 前向声明
  
  class A {
  public:
      std::shared_ptr<B> b_ptr;
      ~A() { std::cout << "A destroyed\n"; }
  };
  
  class B {
  public:
      std::weak_ptr<A> a_ptr; // 使用 weak_ptr 打破循环引用
      ~B() { std::cout << "B destroyed\n"; }
  };
  
  int main() {
      std::shared_ptr<A> a = std::make_shared<A>();
      std::shared_ptr<B> b = std::make_shared<B>();
  
      a->b_ptr = b;
      b->a_ptr = a; // 现在A和B相互引用
  
      // 如果使用 shared_ptr<A> a_ptr;  在B中，则会造成内存泄漏
  
      return 0;
  }

  登录后复制

  登录后复制

  在这个例子中，B类中的a_ptr使用weak_ptr，避免了A和B之间的循环引用，从而防止了内存泄漏。

智能指针的优势

• 自动内存管理：避免手动new和delete，减少内存泄漏的风险。
• 异常安全：即使在抛出异常的情况下，也能保证资源被正确释放。
• 代码简洁：减少了手动内存管理的代码，使代码更易读、易维护。

智能指针并非银弹，选择合适的智能指针类型，并理解其背后的所有权模型，才能真正发挥其优势。

make_unique 和 make_shared 的区别和选择

make_unique (C++14引入) 和 make_shared 都是创建智能指针的推荐方式，但它们之间存在一些关键区别，影响着你的选择。

• make_unique: 专门用于创建 unique_ptr。它直接在一次内存分配中创建对象和 unique_ptr 的控制块（如果存在）。这通常更高效，并且提供了更强的异常安全性。

• make_shared: 用于创建 shared_ptr。它也尝试在一次内存分配中创建对象和 shared_ptr 的控制块（包含引用计数等信息）。然而，make_shared 只能访问对象的公共构造函数。

选择的关键因素：

• 性能: make_shared 在某些情况下可能比单独的 new 和 shared_ptr 构造函数更高效，因为它减少了内存分配的次数。但是，如果对象很大，且频繁分配和释放，这种优势可能会减弱。
• 异常安全性: 使用 make_unique 和 make_shared 可以提供更强的异常安全性，避免在 new 操作和 shared_ptr 构造函数之间抛出异常导致内存泄漏。
• 访问权限: make_shared 只能访问对象的公共构造函数。如果你的对象只有私有或受保护的构造函数，则不能使用 make_shared。
• 自定义删除器: 如果你需要使用自定义删除器，make_unique 和 make_shared 的用法略有不同，但都支持。

总的来说，尽可能使用 make_unique 和 make_shared，除非你有特殊的需求（例如，需要访问私有构造函数或使用自定义删除器）。

如何处理循环引用导致的内存泄漏？

循环引用是使用 shared_ptr 时需要特别注意的问题。当两个或多个对象相互持有对方的 shared_ptr 时，它们的引用计数永远不会降为零，导致对象永远不会被释放，从而造成内存泄漏。

解决方案：weak_ptr

weak_ptr 是解决循环引用的关键。weak_ptr 是一种弱引用，它指向由 shared_ptr 管理的对象，但不增加引用计数。你可以使用 weak_ptr 来打破循环引用。

示例：

#include <iostream>
#include <memory>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destroyed\n"; }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // 使用 weak_ptr 打破循环引用
    ~B() { std::cout << "B destroyed\n"; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->b_ptr = b;
    b->a_ptr = a; // 现在A和B相互引用

    // 如果使用 shared_ptr<A> a_ptr;  在B中，则会造成内存泄漏

    return 0;
}

在这个例子中，B类中的a_ptr使用weak_ptr，避免了A和B之间的循环引用，从而防止了内存泄漏。

使用 weak_ptr 的注意事项：

• 在使用 weak_ptr 访问对象之前，需要先检查对象是否仍然存在。可以使用 weak_ptr::lock() 方法创建一个 shared_ptr，如果对象已经被销毁，则返回空的 shared_ptr。
• weak_ptr 不拥有对象的所有权，因此不能直接通过 weak_ptr 修改对象。

智能指针与原始指针的混合使用：风险与防范

虽然智能指针旨在取代原始指针，但在某些情况下，你可能仍然需要与原始指针交互。这种混合使用带来了风险，需要谨慎处理。

常见风险：

• 双重释放: 多个智能指针或智能指针与原始指针同时管理同一块内存，可能导致重复释放。
• 内存泄漏: 忘记释放原始指针指向的内存，或者智能指针超出作用域但原始指针仍然持有该内存的引用，都可能导致内存泄漏。
• 悬挂指针: 原始指针指向的内存已经被智能指针释放，导致原始指针变成悬挂指针。

防范措施：

• 避免混合使用: 尽可能避免智能指针和原始指针同时管理同一块内存。
• 明确所有权: 明确哪个智能指针拥有对象的唯一所有权。
• 谨慎使用 get() 方法: shared_ptr::get() 方法返回原始指针，但使用时需要非常小心，确保不会导致双重释放或内存泄漏。
• 使用 release() 方法: unique_ptr::release() 方法释放 unique_ptr 对对象的所有权，并返回原始指针。使用后需要手动释放该指针指向的内存。
• 遵循 RAII 原则: 确保资源在对象构造时获取，在对象析构时释放。

示例：避免双重释放

#include <iostream>
#include <memory>

int main() {
    int* raw_ptr = new int(10);
    std::shared_ptr<int> shared_ptr1(raw_ptr);

    // 错误的做法：不要用同一个原始指针创建多个智能指针
    // std::shared_ptr<int> shared_ptr2(raw_ptr); // 错误！会导致双重释放

    // 正确的做法：使用 shared_ptr1
    std::cout << *shared_ptr1 << std::endl;

    return 0;
}

在这个例子中，使用同一个原始指针创建了两个 shared_ptr，当这两个 shared_ptr 超出作用域时，会尝试释放同一块内存两次，导致程序崩溃。

总而言之，虽然智能指针极大地简化了内存管理，但在与原始指针交互时，仍然需要保持警惕，避免潜在的风险。

以上就是C++中如何使用智能指针_智能指针使用指南与示例的详细内容，更多请关注php中文网其它相关文章！