什么是C++中的智能指针 详解unique_ptr shared_ptr weak_ptr用法

c++中的智能指针通过raii机制自动管理内存，避免内存泄漏等问题。1. unique_ptr强调独占所有权，不可复制，支持移动语义，适用于对象仅由一处管理的场景；2. shared_ptr通过引用计数实现共享所有权，多个指针可同时管理同一资源，但需注意循环引用和性能开销；3. weak_ptr作为弱引用不增加引用计数，用于打破shared_ptr的循环引用，适用于观察者或缓存机制。它们共同构成现代c++内存管理的核心工具。

C++中的智能指针，简单来说，就是一种行为类似于指针，但能自动管理内存的类模板。它们的核心价值在于通过RAII（资源获取即初始化）原则，帮助我们避免手动管理内存时常遇到的内存泄漏、野指针和二次释放等问题。这玩意儿简直是现代C++编程的基石，少了它，很多代码写起来都提心吊胆的。

智能指针的出现，彻底改变了我们处理动态内存的方式。它不是什么魔法，本质上就是个封装了原始指针的类，在对象生命周期结束时，自动调用析构函数来释放其管理的内存。这听起来可能有点抽象，但想想看，每次new一个对象后，你是不是总得记得delete它？如果中间抛了异常，或者逻辑分支复杂了，很容易就忘了delete，内存泄漏就发生了。智能指针就是来解决这个痛点的，它确保了资源（这里主要是内存）在不再需要时，会被妥善地释放掉。这就像你租了个房子，智能指针就是那个自动帮你退房、打扫干净的管家，你只管住，不用操心后续。

unique_ptr 到底“独”在哪里？它有哪些典型的使用场景？

unique_ptr，顾名思义，它强调的是“独占”所有权。这意味着一个unique_ptr对象拥有它所指向资源（比如一块内存）的唯一所有权。这东西是不能被复制的，你不能有两个unique_ptr同时指向同一块内存，因为那样就乱套了，谁来负责释放呢？它只支持移动语义，也就是说，所有权可以从一个unique_ptr转移给另一个，但转移之后，原来的那个unique_ptr就不再拥有资源了，它会变成空的。

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

这种独占性让unique_ptr在很多场景下都显得非常有用。比如说，当你需要一个对象，并且明确知道这个对象只会被一个地方拥有和管理时，unique_ptr就是最佳选择。比如一个函数创建了一个新对象，然后把这个对象的管理权“移交”给调用者。

#include 
#include 
#include 

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

// 函数返回一个独占所有权的MyClass对象
std::unique_ptr createMyClass() {
    return std::make_unique(); // 推荐使用make_unique
}

int main() {
    // 独占所有权，不能被复制
    std::unique_ptr ptr1 = std::make_unique();
    ptr1->doSomething();

    // 所有权转移：ptr1的资源转移给ptr2，ptr1变为空
    std::unique_ptr ptr2 = std::move(ptr1);
    if (ptr1 == nullptr) {
        std::cout << "ptr1 is now null after move.\n";
    }
    ptr2->doSomething();

    // 作为函数返回值，实现所有权转移
    std::unique_ptr ptr3 = createMyClass();
    ptr3->doSomething();

    // 将unique_ptr存储在容器中
    std::vector> objects;
    objects.push_back(std::make_unique());
    objects.push_back(std::make_unique());
    // 当objects超出作用域时，其中的MyClass对象都会被自动销毁

    // ptr2和ptr3在main函数结束时会自动销毁其管理的MyClass对象
    return 0;
}

你看，unique_ptr的开销几乎为零，因为它不需要维护引用计数什么的，和原始指针一样高效。它在编译期就能保证内存安全，一旦所有权转移，原指针就失效了，这在逻辑上非常清晰。

shared_ptr 是如何实现共享所有权的？它又带来哪些潜在的问题？

shared_ptr则完全是另一种哲学，它实现了“共享”所有权。这意味着多个shared_ptr对象可以同时指向并管理同一块内存。它通过一个内部的引用计数（reference count）机制来工作：每当一个新的shared_ptr指向同一个资源时，引用计数就加一；每当一个shared_ptr离开作用域或者不再指向该资源时，引用计数就减一。只有当引用计数归零时，shared_ptr才会释放它所管理的内存。这就像一个公共图书馆的书，大家都可以借阅，只要还有人在借，书就不会被扔掉。

LALAL.AI

AI人声去除器和声乐提取工具

下载

#include 
#include 

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

int main() {
    std::shared_ptr ptr1 = std::make_shared(); // 引用计数为1
    std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n";

    std::shared_ptr ptr2 = ptr1; // 引用计数为2
    std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n";
    std::cout << "ptr2 use_count: " << ptr2.use_count() << "\n";

    {
        std::shared_ptr ptr3 = ptr1; // 引用计数为3
        std::cout << "ptr1 use_count (inside scope): " << ptr1.use_count() << "\n";
    } // ptr3离开作用域，引用计数减1，变为2

    std::cout << "ptr1 use_count (after ptr3 scope): " << ptr1.use_count() << "\n";

    ptr1.reset(); // ptr1不再指向资源，引用计数减1，变为1
    std::cout << "ptr2 use_count (after ptr1 reset): " << ptr2.use_count() << "\n";

    // 当ptr2离开作用域时，引用计数变为0，Resource被销毁
    return 0;
}

shared_ptr的便利性毋庸置疑，尤其是在对象生命周期复杂，有多个地方需要访问同一个对象时。但它也带来了几个潜在的问题，其中最臭名昭著的就是“循环引用”（circular reference）。如果两个或多个shared_ptr相互持有对方的shared_ptr，就会形成一个闭环。在这种情况下，即使外部已经没有其他shared_ptr指向它们了，它们的引用计数也永远不会降到零，导致它们所管理的内存永远不会被释放，这就造成了内存泄漏。

此外，shared_ptr相比unique_ptr会带来一些性能开销。因为它需要维护一个引用计数，这个计数器通常是原子操作，以保证多线程环境下的正确性。原子操作比普通操作要慢，虽然在大多数情况下这点开销可以忽略不计，但在性能敏感的场景下，也需要考虑。

weak_ptr 的存在意义是什么？它如何解决 shared_ptr 的循环引用问题？

weak_ptr就是为了解决shared_ptr的循环引用问题而诞生的。它是一种“弱引用”或者说“非拥有”的智能指针。weak_ptr可以指向一个由shared_ptr管理的对象，但它不会增加对象的引用计数。这就像一个观察者，它知道有这本书在那里，但它并没有借阅这本书，所以它不会影响书的借阅计数。

因为weak_ptr不拥有资源，所以它不能直接访问资源。要访问它指向的对象，你必须先调用它的lock()方法，lock()会尝试返回一个shared_ptr。如果它指向的对象还存在（即其shared_ptr的引用计数不为零），lock()就会成功返回一个shared_ptr；如果对象已经被销毁了（因为所有shared_ptr都已失效），lock()就会返回一个空的shared_ptr。通过这种方式，weak_ptr提供了一种安全地访问共享对象的方式，同时又不会阻止对象的销毁。

#include 
#include 

class B; // 前向声明

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

class B {
public:
    // 这里使用weak_ptr来打破循环引用
    std::weak_ptr a_ptr; 
    B() { std::cout << "B created!\n"; }
    ~B() { std::cout << "B destroyed!\n"; }
};

int main() {
    std::shared_ptr sp_a = std::make_shared();
    std::shared_ptr sp_b = std::make_shared();

    std::cout << "A use_count: " << sp_a.use_count() << "\n"; // 1
    std::cout << "B use_count: " << sp_b.use_count() << "\n"; // 1

    sp_a->b_ptr = sp_b; // A持有B的shared_ptr，B的引用计数变为2
    // sp_b->a_ptr = sp_a; // 如果这里也用shared_ptr，就形成循环引用了

    // 使用weak_ptr来持有A，不会增加A的引用计数
    sp_b->a_ptr = sp_a; 

    std::cout << "After linking:\n";
    std::cout << "A use_count: " << sp_a.use_count() << "\n"; // 1 (因为B持有的a_ptr是weak_ptr)
    std::cout << "B use_count: " << sp_b.use_count() << "\n"; // 2 (因为A持有的b_ptr是shared_ptr)

    // 尝试通过weak_ptr访问A
    if (auto sharedA = sp_b->a_ptr.lock()) {
        std::cout << "A is still alive, use_count: " << sharedA.use_count() << "\n";
    } else {
        std::cout << "A is gone.\n";
    }

    // 当sp_a和sp_b离开作用域时，它们各自的引用计数会变为0，对象会被正确销毁
    // 如果sp_b->a_ptr也是shared_ptr，那么sp_a和sp_b的引用计数永远是1，不会销毁
    return 0;
}

在这个例子里，A拥有一个B的shared_ptr，而B则拥有一个A的weak_ptr。当main函数结束，sp_a和sp_b离开作用域时，sp_a的引用计数首先降为0，A对象被销毁。接着，sp_b的引用计数也降为0，B对象被销毁。整个过程没有内存泄漏。如果没有weak_ptr，A和B就会互相牵制，导致内存泄露。