请解释C++11中的智能指针类型及其使用场景，并说明它们如何帮助管理内存。

C++11中的智能指针类型及其使用场景

C++11引入了三种主要的智能指针类型：unique_ptr、shared_ptr和weak_ptr。这些智能指针是RAII（Resource Acquisition Is Initialization）原则的典型应用，它们封装了原始指针，并在适当的时候自动释放所管理的内存，从而帮助开发者避免内存泄漏。

1. unique_ptr

unique_ptr是一种独占所有权的智能指针，同一时刻只能有一个unique_ptr指向特定对象。当unique_ptr被销毁时（例如离开作用域），它所指向的对象也会被自动删除。

特点：

• 独占所有权，不能复制，只能移动
• 轻量级，性能接近原始指针
• 适用于明确对象生命周期的场景

使用场景：

• 当资源的所有权需要明确且独占时
• 工厂模式返回的对象
• Pimpl（Pointer to Implementation）惯用法

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructed\n"; }
    ~MyClass() { std::cout << "MyClass destroyed\n"; }
    void doSomething() { std::cout << "Doing something\n"; }
};

void uniquePtrExample() {
    // 创建unique_ptr
    std::unique_ptr<MyClass> ptr1(new MyClass());
    
    // 使用->访问成员
    ptr1->doSomething();
    
    // 不能复制，只能移动
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1);
    
    // ptr1现在为空
    if (!ptr1) {
        std::cout << "ptr1 is empty\n";
    }
    
    // ptr2离开作用域时，自动删除对象
}

2. shared_ptr

shared_ptr是一种共享所有权的智能指针，多个shared_ptr可以指向同一个对象。它使用引用计数机制来跟踪有多少个shared_ptr指向同一个对象。当最后一个指向该对象的shared_ptr被销毁时，对象才会被删除。

特点：

• 共享所有权，可以复制
• 使用引用计数
• 适用于复杂的对象生命周期管理

使用场景：

• 多个组件需要共享同一个对象
• 缓存系统
• 观察者模式中的主题对象

#include <memory>
#include <iostream>
#include <vector>

class Resource {
public:
    Resource() { std::cout << "Resource created\n"; }
    ~Resource() { std::cout << "Resource destroyed\n"; }
    void use() { std::cout << "Using resource\n"; }
};

void sharedPtrExample() {
    // 创建shared_ptr
    std::shared_ptr<Resource> ptr1(new Resource());
    
    // 引用计数为1
    std::cout << "Reference count: " << ptr1.use_count() << "\n";
    
    {
        // 复制shared_ptr，引用计数增加
        std::shared_ptr<Resource> ptr2 = ptr1;
        std::cout << "Reference count: " << ptr1.use_count() << "\n";
        
        // 使用资源
        ptr2->use();
        
        // ptr2离开作用域，引用计数减少
    }
    
    // 引用计数回到1
    std::cout << "Reference count: " << ptr1.use_count() << "\n";
    
    // 可以存储在容器中
    std::vector<std::shared_ptr<Resource>> resources;
    resources.push_back(ptr1);
    std::cout << "Reference count: " << ptr1.use_count() << "\n";
    
    // ptr1离开作用域，引用计数变为0，资源被自动删除
}

3. weak_ptr

weak_ptr是一种不控制对象生命周期的智能指针，它指向一个由shared_ptr管理的对象，但不会增加引用计数。它主要用于解决shared_ptr之间的循环引用问题。

特点：

• 不控制对象生命周期
• 不增加引用计数
• 需要检查对象是否存在才能访问

使用场景：

• 解决shared_ptr的循环引用问题
• 观察者模式中观察者的实现
• 缓存系统中的弱引用

#include <memory>
#include <iostream>

class Node {
public:
    std::string name;
    std::shared_ptr<Node> next;  // 使用shared_ptr可能导致循环引用
    std::weak_ptr<Node> weakNext;  // 使用weak_ptr避免循环引用
    
    Node(const std::string& n) : name(n) {
        std::cout << "Node " << name << " created\n";
    }
    
    ~Node() {
        std::cout << "Node " << name << " destroyed\n";
    }
};

void weakPtrExample() {
    // 创建两个节点
    std::shared_ptr<Node> node1 = std::make_shared<Node>("Node1");
    std::shared_ptr<Node> node2 = std::make_shared<Node>("Node2");
    
    // 使用weak_ptr避免循环引用
    node1->weakNext = node2;
    node2->weakNext = node1;
    
    // 检查weak_ptr是否有效
    if (auto locked = node1->weakNext.lock()) {
        std::cout << "Node1's next is: " << locked->name << "\n";
    } else {
        std::cout << "Node1's next is expired\n";
    }
    
    // 当node1和node2离开作用域时，它们会被正确删除
    // 因为weak_ptr不增加引用计数
}

智能指针如何帮助管理内存

智能指针通过RAII原则帮助管理内存，具体体现在以下几个方面：

1. 自动内存释放：智能指针在析构函数中自动释放所管理的内存，避免了忘记调用delete导致的内存泄漏。

2. 明确的资源所有权：

   • unique_ptr表示独占所有权
   • shared_ptr表示共享所有权
   • weak_ptr表示非拥有引用

3. 异常安全：即使在异常发生时，智能指针也能确保资源被正确释放。

4. 避免悬空指针：智能指针在对象被销毁后会自动设置为空，减少了使用悬空指针的风险。

5. 解决循环引用：weak_ptr可以解决shared_ptr之间的循环引用问题，防止内存泄漏。

智能指针的选择指南

智能指针的最佳实践

1. 优先使用std::make_unique和std::make_shared：

   // 推荐
   auto ptr1 = std::make_unique<MyClass>();
   auto ptr2 = std::make_shared<MyClass>();
   
   // 不推荐
   std::unique_ptr<MyClass> ptr1(new MyClass());
   std::shared_ptr<MyClass> ptr2(new MyClass());
   

2. 避免将原始指针和智能指针混合使用：

   // 危险
   MyClass* raw = new MyClass();
   std::unique_ptr<MyClass> smart(raw);
   // 删除raw会导致smart成为悬空指针
   delete raw;
   

3. 使用weak_ptr解决循环引用：

   class A {
   public:
       std::shared_ptr<B> b;
   };
   
   class B {
   public:
       std::weak_ptr<A> a;  // 使用weak_ptr避免循环引用
   };
   

4. 注意线程安全：

   • shared_ptr的引用计数操作是原子操作，是线程安全的
   • 但通过shared_ptr访问对象不是线程安全的，需要额外的同步机制

参考链接：

1. cppreference.com - 智能指针
2. Microsoft Docs - 智能指针
3. C++ Core Guidelines - 资源管理