C++智能指针详解

FFlyHero

350人浏览 · 2026-04-25 18:36:09

FFlyHero · 2026-04-25 18:36:09 发布

各位C++开发者们，是不是都被内存泄漏、野指针这些问题折磨过？

手动管理内存的时候，一个不小心忘记delete，或者在复杂的分支逻辑里重复释放，程序轻则崩溃，重则埋下难以排查的隐患。今天咱们就来彻底搞懂C++里的"内存管理救星"——智能指针。

一、智能指针到底是什么？

简单来说，智能指针就是C++标准库提供的封装了普通指针的类模板。它的核心原理是利用C++的RAII机制（资源获取即初始化）：在对象构造时获取资源，在对象生命周期结束（析构函数被调用）时自动释放资源。

打个比方，普通指针就像你租了房子但忘了交钥匙，得自己记着退房；而智能指针就像带了自动退房功能的租房合同，合同到期（对象销毁），钥匙自动归还，再也不用担心忘退房的问题。

二、常见智能指针类型及原理

C++标准库提供了三种最常用的智能指针：unique_ptr、shared_ptr、weak_ptr，咱们一个个说清楚：

1. unique_ptr：独占式智能指针

核心原理：它是一个独占所有权的智能指针，同一时间只能有一个unique_ptr指向某个对象，禁止拷贝操作，只能通过移动语义转移所有权。
适用场景：当你明确知道某个资源只会被一个指针管理时，比如局部对象、独占的资源句柄。

2. shared_ptr：共享式智能指针

核心原理：它通过引用计数机制实现共享所有权。每多一个shared_ptr指向同一个对象，引用计数就加1；当shared_ptr被销毁或指向其他对象时，引用计数减1。当引用计数变为0时，自动释放所指向的对象。
适用场景：需要多个指针共享同一个资源的场景，比如多个对象共同管理一个动态分配的数据结构。

3. weak_ptr：辅助式智能指针

核心原理：它是为了解决shared_ptr的循环引用问题而生的。它指向shared_ptr管理的对象，但不会增加引用计数，相当于一个"观察者"，可以随时获取有效的shared_ptr，但不会影响对象的生命周期。
适用场景：解决父子对象相互持有shared_ptr导致的循环引用问题。

三、实操代码案例

说了这么多，咱们直接上代码，看看这三种智能指针具体怎么用：

1. unique_ptr 示例

#include <iostream>
#include <memory> // 必须包含的头文件

class MyClass {
public:
    MyClass() { std::cout << "MyClass 构造" << std::endl; }
    ~MyClass() { std::cout << "MyClass 析构" << std::endl; }
    void doSomething() { std::cout << "执行操作" << std::endl; }
};

int main() {
    // 1. 创建unique_ptr，独占MyClass对象
    std::unique_ptr<MyClass> ptr1(new MyClass());
    ptr1->doSomething();

    // 2. 不能直接拷贝，编译报错
    // std::unique_ptr<MyClass> ptr2 = ptr1; 

    // 3. 通过move转移所有权，转移后ptr1不再指向对象
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1);
    if (!ptr1) {
        std::cout << "ptr1已为空" << std::endl;
    }
    ptr2->doSomething();

    // 4. 函数结束时，ptr2自动销毁，调用MyClass的析构函数
    return 0;
}

代码说明：

必须包含<memory>头文件才能使用智能指针
unique_ptr禁止拷贝，只能用std::move转移所有权
无需手动调用delete，对象会在unique_ptr生命周期结束时自动释放

2. shared_ptr 示例

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass 构造" << std::endl; }
    ~MyClass() { std::cout << "MyClass 析构" << std::endl; }
};

int main() {
    // 1. 创建shared_ptr，引用计数初始为1
    std::shared_ptr<MyClass> ptr1(new MyClass());
    std::cout << "ptr1的引用计数：" << ptr1.use_count() << std::endl;

    // 2. 拷贝ptr1，引用计数加1，变为2
    std::shared_ptr<MyClass> ptr2 = ptr1;
    std::cout << "ptr2的引用计数：" << ptr2.use_count() << std::endl;

    // 3. ptr1重置，引用计数减1，变为1
    ptr1.reset();
    std::cout << "ptr1重置后，ptr2的引用计数：" << ptr2.use_count() << std::endl;

    // 4. main函数结束，ptr2销毁，引用计数变为0，自动调用析构函数
    return 0;
}

代码说明：

use_count()方法可以查看当前的引用计数
多个shared_ptr共享同一个对象，只有当所有shared_ptr都销毁时，对象才会被释放
推荐使用std::make_shared创建shared_ptr，比直接new更高效且更安全：auto ptr = std::make_shared<MyClass>();

3. weak_ptr 解决循环引用示例

#include <iostream>
#include <memory>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A 析构" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // 使用weak_ptr而非shared_ptr
    ~B() { std::cout << "B 析构" << std::endl; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    // 相互引用
    a->b_ptr = b;
    b->a_ptr = a;

    std::cout << "a的引用计数：" << a.use_count() << std::endl; // 输出1
    std::cout << "b的引用计数：" << b.use_count() << std::endl; // 输出1

    // main函数结束，a和b销毁，引用计数变为0，A和B都会被析构
    return 0;
}