现代C++智能指针有哪些类型 shared_ptr unique_ptr使用场景对比

c++++中的智能指针unique_ptr和shared_ptr通过raii机制自动管理内存生命周期，避免内存泄漏和野指针问题。1. unique_ptr强调独占所有权，资源只能被一个指针持有，不可复制只能移动，适用于单一所有者明确控制资源生命周期的场景，如工厂函数返回值、类成员变量、局部变量管理动态内存；2. shared_ptr允许多个指针共享资源，通过引用计数决定释放时机，适合生命周期依赖多个持有者的场景，如缓存机制、观察者模式、图结构节点、共享配置数据等；3. shared_ptr存在循环引用导致内存泄漏的风险，需引入weak_ptr打破循环，weak_ptr不增加引用计数，仅用于临时访问shared_ptr管理的对象；4. 实际项目中应优先考虑unique_ptr，因其轻量高效，只有在确实需要共享所有权时才使用shared_ptr，并警惕循环引用问题，合理使用weak_ptr规避风险。

现代C++中的智能指针，尤其是

unique_ptr

shared_ptr

unique_ptr

unique_ptr

shared_ptr

智能指针的核心价值与现代C++实践

在C++11及以后的版本里，智能指针几乎成了动态内存管理的标准答案。过去我们手动

new

delete

unique_ptr

unique_ptr

unique_ptr

unique_ptr

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

而

shared_ptr

shared_ptr

shared_ptr

shared_ptr

shared_ptr

unique_ptr

的适用场景与设计哲学

unique_ptr

unique_ptr

想想那些需要明确生命周期的资源：

• 工厂函数的返回值：一个函数负责创建对象，并将这个新创建的对象的所有权转移给调用者。例如：

  std::unique_ptr createMyObject() {
      return std::make_unique();
  }
  // 调用者获得所有权
  auto obj = createMyObject();

  这里，

  createMyObject

  函数创建了一个

  MyClass

  实例，并将其所有权“移动”给了

  obj

  。当

  obj

  超出作用域时，

  MyClass

  实例会被自动销毁。

• 类成员变量：当一个类内部包含一个动态分配的对象，并且这个对象的生命周期完全由该类的实例控制时。

  class ResourceManager {
  public:
      ResourceManager() : data_(std::make_unique(100)) {}
      // ...
  private:
      std::unique_ptr data_; // data_的生命周期与ResourceManager实例绑定
  };

• 局部变量管理动态内存：在函数内部临时使用动态内存，但不需要将其所有权传递出去。

  void processLargeData() {
      std::unique_ptr buffer = std::make_unique(1024 * 1024);
      // 使用buffer进行计算
      // 函数结束时，buffer自动释放
  }

  unique_ptr

  的优势在于其零开销抽象：它在运行时几乎没有额外的性能负担，因为它不需要进行引用计数操作。它的所有权转移是通过C++11的移动语义实现的，这是一种非常高效的操作。所以，只要你能明确资源的单一所有权，就应该毫不犹豫地选择

  unique_ptr

  。这不仅能提升性能，也能让代码的意图更加清晰。

shared_ptr

的适用场景与潜在陷阱

shared_ptr

shared_ptr

典型的使用场景包括：

sematic

一个开源的机器学习平台

下载

• 缓存机制：多个客户端可能需要访问同一个缓存项。只要有客户端还在使用这个缓存项，它就应该存在。

• 观察者模式：一个主题对象可能被多个观察者共享，只要有观察者还“观察”着它，它就不应该被销毁。

• 图结构中的节点：图中的一个节点可能被多个其他节点引用，其生命周期取决于所有引用它的节点。

• 共享配置或数据：应用程序中多个模块需要访问同一份配置数据，并且这份数据的生命周期与所有模块相关。

  class Config { /* ... */ };
  std::shared_ptr globalConfig = std::make_shared();
  
  void moduleA(std::shared_ptr cfg) { /* 使用cfg */ }
  void moduleB(std::shared_ptr cfg) { /* 使用cfg */ }
  
  // moduleA和moduleB可以同时持有globalConfig的引用
  // 只有当所有shared_ptr都不再引用它时，globalConfig才会被销毁

然而，

shared_ptr

shared_ptr

例如：

class B; // 前向声明

class A {
public:
    std::shared_ptr b_ptr;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::shared_ptr a_ptr;
    ~B() { std::cout << "B destroyed" << std::endl; }
};

void test_circular_dependency() {
    auto a = std::make_shared();
    auto b = std::make_shared();

    a->b_ptr = b;
    b->a_ptr = a;
    // 此时a和b的引用计数都为2。
    // 当a和b离开作用域时，它们的引用计数会减到1，但永远不会到0，导致内存泄漏。
}

为了解决这个问题，C++引入了

std::weak_ptr

weak_ptr

shared_ptr

weak_ptr

lock()

shared_ptr

lock()

shared_ptr

class B;

class A {
public:
    std::shared_ptr b_ptr;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

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

void test_fixed_circular_dependency() {
    auto a = std::make_shared();
    auto b = std::make_shared();

    a->b_ptr = b;
    b->a_ptr = a; // 此时a的引用计数为1，b的引用计数为1
    // 当a和b离开作用域时，它们的引用计数都会减到0，对象会被正确销毁。
}

shared_ptr

unique_ptr

shared_ptr

unique_ptr

shared_ptr

unique_ptr

shared_ptr

weak_ptr