C++智能指针详解

智能指针的概念

智能指针是C++中的一种对象，它行为像指针但具有额外的功能，主要是自动管理内存。智能指针在析构时会自动释放所拥有的内存，从而避免内存泄漏。这是C++11引入的重要特性，用于解决原始指针可能导致的内存管理问题。

智能指针的类型

C++标准库中主要提供了三种智能指针：

1. std::unique_ptr
2. std::shared_ptr
3. std::weak_ptr

下面我将详细解释每种智能指针的特点和使用场景。

std::unique_ptr

std::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"; }
};

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

std::shared_ptr

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

特点

• 共享所有权，可以复制
• 使用引用计数机制
• 比unique_ptr重量级，因为需要维护引用计数
• 支持自定义删除器

使用场景

• 当多个对象需要共享同一个资源时
• 复杂的对象关系图
• 缓存系统
• 观察者模式中的通知机制

示例代码

#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"; }
};

int main() {
    // 创建shared_ptr
    std::shared_ptr<MyClass> ptr1(new MyClass());
    
    // 输出引用计数
    std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n";
    
    // 复制shared_ptr，引用计数增加
    std::shared_ptr<MyClass> ptr2 = ptr1;
    std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n";
    std::cout << "ptr2 use_count: " << ptr2.use_count() << "\n";
    
    // 使用->访问成员
    ptr1->doSomething();
    ptr2->doSomething();
    
    // ptr2离开作用域，引用计数减少
    {
        std::shared_ptr<MyClass> ptr3 = ptr1;
        std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n";
    } // ptr3离开作用域
    
    std::cout << "After ptr3 destroyed, ptr1 use_count: " << ptr1.use_count() << "\n";
    
    // 当最后一个shared_ptr离开作用域时，对象会被删除
    return 0;
}

std::weak_ptr

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

特点

• 不控制对象生命周期，不增加引用计数
• 需要转换为shared_ptr才能访问对象
• 用于观察shared_ptr管理的对象，但不影响其生命周期
• 可以检查对象是否已被删除

使用场景

• 解决shared_ptr之间的循环引用问题
• 观察者模式中，避免强引用导致的对象无法释放
• 缓存系统，当缓存对象可能被删除时
• 打破对象之间的循环依赖

示例代码

#include <memory>
#include <iostream>

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

int main() {
    // 创建两个节点
    std::shared_ptr<Node> node1 = std::make_shared<Node>("Node1");
    std::shared_ptr<Node> node2 = std::make_shared<Node>("Node2");
    
    // 设置双向链接
    node1->next = node2;
    node2->prev = node1;  // 使用weak_ptr
    
    // 检查引用计数
    std::cout << "node1 use_count: " << node1.use_count() << "\n";
    std::cout << "node2 use_count: " << node2.use_count() << "\n";
    
    // 通过weak_ptr访问对象
    if (auto locked = node2->prev.lock()) {
        std::cout << "Previous node is " << locked->name << "\n";
    } else {
        std::cout << "Previous node has been destroyed\n";
    }
    
    // node1和node2离开作用域时，可以正常释放
    return 0;
}

智能指针的选择指南

选择哪种智能指针取决于具体的使用场景：

1. 使用std::unique_ptr当：

   • 资源所有权需要明确且独占
   • 性能是关键考虑因素
   • 对象生命周期清晰且不需要共享

2. 使用std::shared_ptr当：

   • 多个对象需要共享同一个资源
   • 不确定对象的确切生命周期
   • 需要共享所有权

3. 使用std::weak_ptr当：

   • 需要观察shared_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. 避免混合使用原始指针和智能指针：

   • 这可能导致混乱的所有权语义和潜在的错误

3. 注意循环引用：

   • 当两个对象通过shared_ptr相互引用时，会导致内存泄漏
   • 使用weak_ptr打破循环引用

4. 自定义删除器：

   • 智能指针支持自定义删除器，用于管理非内存资源

   auto fileDeleter = [](FILE* f) { if (f) fclose(f); };
   std::unique_ptr<FILE, decltype(fileDeleter)> file(fopen("example.txt", "r"), fileDeleter);
   

智能指针的局限性

1. 性能开销：

   • shared_ptr有引用计数的开销
   • 智能指针比原始指针占用更多内存

2. 不能管理所有资源：

   • 智能指针主要用于堆内存管理
   • 其他资源（如文件句柄、网络连接）需要自定义删除器

3. 循环引用问题：

   • shared_ptr之间的循环引用会导致内存泄漏
   • 需要使用weak_ptr来解决这个问题

参考文档

1. cppreference.com - 智能指针
2. Microsoft Docs - 智能指针
3. LearnCpp.com - 智能指针