C++智能指针类型及用法详解

C++智能指针主要有unique_ptr、shared_ptr和weak_ptr三种类型，它们基于RAII原则实现自动化内存管理，避免内存泄漏和悬空指针问题；unique_ptr提供独占所有权且高效，适用于单一所有者场景；shared_ptr通过引用计数实现共享所有权，适合多对象共用资源的情况；weak_ptr作为弱引用不增加引用计数，用于打破shared_ptr的循环引用并安全观察对象生命周期，三者结合使用可显著提升C++程序的内存安全与代码健壮性。

C++智能指针主要有三种类型：unique_ptr、shared_ptr和weak_ptr。它们的核心作用在于自动化内存管理，极大简化了C++中资源生命周期的控制，有效避免了内存泄漏和悬空指针等问题。简单来说，它们让C++的内存管理变得更安全、更省心。

解决方案

说实话，刚接触C++那会儿，手动管理内存真是个噩梦。new了就得记得delete，稍微一疏忽，内存泄漏就找上门，程序崩溃更是家常便饭。直到智能指针的出现，才感觉C++在现代编程语言的内存管理上真正迈出了一大步。它们并非什么魔法，而是基于RAII（Resource Acquisition Is Initialization）原则，也就是资源在对象构造时获取，在对象析构时释放。这就像是给内存资源套上了一层“自动回收器”，当智能指针对象超出作用域时，它所管理的内存也会被自动释放掉，省去了我们手动delete的烦恼。

这三种智能指针各司其职，解决了不同场景下的内存所有权问题。unique_ptr强调独占，shared_ptr实现共享，而weak_ptr则像是旁观者，用于解决shared_ptr可能带来的循环引用问题。理解它们各自的特点和适用场景，是写出健壮C++代码的关键一步。

unique_ptr的独特所有权与高效管理

unique_ptr，顾名思义，它拥有对所指向对象的“独占”所有权。这意味着在任何时间点，一个特定的对象只能被一个unique_ptr拥有。这种所有权是不能被复制的，但可以被“移动”。我个人觉得，unique_ptr是日常开发中最常用也最推荐的智能指针，因为它几乎没有运行时开销，跟原始指针一样高效，却提供了自动释放内存的便利。

它特别适合那些资源必须有且只有一个明确所有者的场景，比如文件句柄、网络连接、或者某个类的内部成员，这些资源一旦被创建，就应该由某个特定的实体负责其生命周期。当你需要将资源的所有权从一个地方转移到另一个地方时，std::move就派上用场了。

#include 
#include 
#include 

class MyResource {
public:
    MyResource(int id) : id_(id) {
        std::cout << "MyResource " << id_ << " created." << std::endl;
    }
    ~MyResource() {
        std::cout << "MyResource " << id_ << " destroyed." << std::endl;
    }
    void do_something() {
        std::cout << "MyResource " << id_ << " doing something." << std::endl;
    }
private:
    int id_;
};

void process_resource(std::unique_ptr res) {
    if (res) { // 检查是否为空
        res->do_something();
    }
    // res 在这里超出作用域，MyResource 自动销毁
}

int main() {
    // 创建一个 unique_ptr
    std::unique_ptr ptr1 = std::make_unique(1);
    ptr1->do_something();

    // 尝试复制会编译错误：
    // std::unique_ptr ptr2 = ptr1; // 编译错误

    // 移动所有权
    std::unique_ptr ptr2 = std::move(ptr1);
    if (!ptr1) { // ptr1 现在是空的
        std::cout << "ptr1 is now empty after move." << std::endl;
    }
    ptr2->do_something();

    // 将所有权传递给函数
    process_resource(std::move(ptr2));
    if (!ptr2) {
        std::cout << "ptr2 is now empty after passing to function." << std::endl;
    }

    // 在容器中使用 unique_ptr
    std::vector> resources;
    resources.push_back(std::make_unique(3));
    resources.push_back(std::make_unique(4));
    // 当 resources 向量超出作用域时，其中的 MyResource 对象也会自动销毁

    std::cout << "Main function ending." << std::endl;
    return 0;
}

使用std::make_unique来创建unique_ptr是个好习惯，它能避免一些潜在的异常安全问题，并且通常效率更高，因为它只进行一次内存分配。

shared_ptr如何实现共享所有权与引用计数

有时候，一个资源可能需要被多个地方共同拥有，比如一个配置对象，或者一个大的数据结构，多个模块都需要访问它，并且当最后一个使用者不再需要它时，它才应该被销毁。这时，shared_ptr就派上用场了。shared_ptr通过引用计数（reference counting）机制来实现共享所有权：每当有一个新的shared_ptr指向同一个对象时，引用计数就增加；当一个shared_ptr被销毁或指向其他对象时，引用计数就减少。当引用计数归零时，shared_ptr会自动删除它所管理的对象。

这种机制听起来很方便，确实也解决了许多复杂场景下的内存管理问题。比如在构建图结构、观察者模式或者缓存系统时，shared_ptr能让逻辑变得清晰很多。

#include 
#include 
#include 

class SharedResource {
public:
    SharedResource(int id) : id_(id) {
        std::cout << "SharedResource " << id_ << " created." << std::endl;
    }
    ~SharedResource() {
        std::cout << "SharedResource " << id_ << " destroyed." << std::endl;
    }
    void use() {
        std::cout << "SharedResource " << id_ << " is being used." << std::endl;
    }
private:
    int id_;
};

int main() {
    std::shared_ptr ptrA = std::make_shared(100);
    std::cout << "ptrA ref count: " << ptrA.use_count() << std::endl; // 1

    std::shared_ptr ptrB = ptrA; // 复制所有权
    std::cout << "ptrA ref count: " << ptrA.use_count() << std::endl; // 2
    std::cout << "ptrB ref count: " << ptrB.use_count() << std::endl; // 2

    {
        std::shared_ptr ptrC = ptrA; // 再次复制
        std::cout << "ptrA ref count: " << ptrA.use_count() << std::endl; // 3
        ptrC->use();
    } // ptrC 超出作用域，引用计数减1

    std::cout << "ptrA ref count after C out of scope: " << ptrA.use_count() << std::endl; // 2

    ptrB.reset(); // ptrB 放弃所有权，引用计数减1
    std::cout << "ptrA ref count after B reset: " << ptrA.use_count() << std::endl; // 1

    // 当 ptrA 超出作用域时，引用计数变为0，SharedResource 100 被销毁
    std::cout << "Main function ending." << std::endl;
    return 0;
}

同样，std::make_shared是创建shared_ptr的首选方式，因为它能在一个内存块中同时分配对象本身和引用计数器，这比先new对象再用shared_ptr管理要高效得多。不过，shared_ptr也有它的缺点，最主要的就是循环引用问题，这正是weak_ptr存在的理由。

weak_ptr为何能打破循环引用并安全观察

shared_ptr虽然强大，但它有一个著名的“坑”：循环引用。如果两个或多个shared_ptr相互持有对方的引用，那么它们的引用计数永远不会降到零，导致内存泄漏。比如，对象A有一个shared_ptr指向B，对象B有一个shared_ptr指向A，它们会形成一个死循环，谁也无法释放。

weak_ptr就是为了解决这个问题而生的。它是一种不拥有对象所有权的智能指针，它只是对shared_ptr所管理对象的一个“弱引用”或者说“观察者”。weak_ptr不会增加对象的引用计数，所以它不会阻止对象被销毁。当你需要访问weak_ptr所指向的对象时，你需要先调用它的lock()方法，尝试获取一个shared_ptr。如果对象仍然存在，lock()会返回一个有效的shared_ptr；如果对象已经被销毁，它会返回一个空的shared_ptr。

这使得weak_ptr非常适合用于那些需要访问但又不能拥有所有权的场景，比如缓存管理器（缓存项不应该阻止自身被清理）、父子关系（子节点可以强引用父节点，但父节点对子节点使用弱引用，避免循环）、或者观察者模式中观察者对被观察者的引用。

#include 
#include 

class B; // 前向声明

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

class B {
public:
    std::weak_ptr a_ptr; // 使用 weak_ptr 避免循环引用
    B() { std::cout << "B created." << std::endl; }
    ~B() { std::cout << "B destroyed." << std::endl; }
    void check_a() {
        if (auto sharedA = a_ptr.lock()) { // 尝试获取 shared_ptr
            std::cout << "B can still access A." << std::endl;
        } else {
            std::cout << "A has been destroyed." << std::endl;
        }
    }
};

int main() {
    std::cout << "--- Demonstrating shared_ptr circular reference (conceptual) ---" << std::endl;
    // 如果这里 A 和 B 都用 shared_ptr 互相引用，它们将永远不会被销毁
    // std::shared_ptr a = std::make_shared();
    // std::shared_ptr b = std::make_shared();
    // a->b_ptr = b;
    // b->a_ptr = a; // 引用计数永远不会归零

    std::cout << "\n--- Demonstrating weak_ptr breaking circular reference ---" << std::endl;
    std::shared_ptr a_obj = std::make_shared();
    std::shared_ptr b_obj = std::make_shared();

    a_obj->b_ptr = b_obj; // A 强引用 B
    b_obj->a_ptr = a_obj; // B 弱引用 A

    std::cout << "A ref count: " << a_obj.use_count() << std::endl; // 1 (只有 b_obj->a_ptr 不增加引用计数)
    std::cout << "B ref count: " << b_obj.use_count() << std::endl; // 2 (a_obj->b_ptr 和 b_obj 自身)

    b_obj->check_a(); // A 还在，可以访问

    // 销毁 a_obj
    a_obj.reset(); 
    std::cout << "A ref count after reset: " << (a_obj ? a_obj.use_count() : 0) << std::endl; // 0
    std::cout << "B ref count after A reset: " << b_obj.use_count() << std::endl; // 1 (只有 b_obj 自身)

    b_obj->check_a(); // A 已经销毁，无法访问

    std::cout << "Main function ending." << std::endl;
    return 0;
}

通过weak_ptr，我们可以安全地检查对象是否存在，并在需要时临时提升为shared_ptr进行操作，避免了内存泄漏的风险。这在设计复杂的、相互关联的对象系统时，显得尤为重要。

总结一下，C++的智能指针家族为我们提供了强大的工具来管理动态内存。unique_ptr是默认首选，用于独占所有权；shared_ptr用于共享所有权，但要小心循环引用；而weak_ptr则是shared_ptr的完美搭档，用于打破循环引用并安全地观察对象生命周期。理解并恰当使用它们，能让我们的C++代码更加健壮和高效。