C++ 智能指针 - 技术栈

作为C++开发者，内存管理永远是绕不开的话题。你是否也曾因为忘记写delete导致内存泄漏？是否因为重复释放指针让程序崩溃？是否被野指针、悬空指针搞得焦头烂额？

其实，C++标准库早已为我们提供了"神器"------智能指针。它能自动帮我们管理内存，让我们从手动new/delete的繁琐与风险中解放出来。今天，就带大家从原理到实战，彻底搞懂智能指针，让内存管理变得轻松简单。

一、为什么需要智能指针？先看原生指针的"坑"

在C++中，我们常用原生指针（如int*、char*）来操作动态内存，通过new分配内存，delete释放内存。但这种手动管理方式，很容易踩坑，常见问题有3个：

内存泄漏：最常见的问题。比如分配内存后忘记写delete，或者程序提前return、抛出异常，导致delete无法执行，内存永远无法释放，长期运行会导致程序占用内存越来越大，最终崩溃。
重复释放：同一个指针被多次delete，会导致程序崩溃。比如多个指针指向同一块内存，每个指针都执行delete，就会触发未定义行为。
野指针/悬空指针：指针指向的内存被释放后，指针本身没有被置空，后续再使用这个指针，就会访问无效内存，导致程序崩溃或数据错乱。

举个简单的反例，这段代码看似正常，实则暗藏风险：

cpp 复制代码

#include <iostream>
using namespace std;

int main() {
    int* p = new int(10); // 分配内存
    if (true) {
        return 0; // 提前return，delete未执行，内存泄漏
    }
    delete p; // 永远不会执行
    p = nullptr;
    return 0;
}

而智能指针的出现，就是为了彻底解决这些问题。它的核心逻辑很简单：将原生指针包装成一个类对象，利用C++的RAII（资源获取即初始化）机制，在对象生命周期结束时，自动调用析构函数释放内存，无需手动干预。

二、智能指针的核心原理：RAII机制

在讲具体的智能指针之前，我们先搞懂它的底层核心------RAII（Resource Acquisition Is Initialization），即"资源获取即初始化"。

RAII的核心思想是：将资源（如动态内存、文件句柄、网络连接等）的获取和初始化绑定在一起，将资源的释放和对象的析构绑定在一起。

当我们创建智能指针对象时，它会自动获取动态内存资源（通过构造函数）；当智能指针对象离开作用域（比如函数结束、代码块结束），会自动调用析构函数，释放绑定的内存资源。

简单来说，智能指针就是"自动帮你管delete的指针"，你只需要负责new（甚至不用手动new，后面会讲），剩下的释放工作，它全帮你搞定。

三、C++常用智能指针：3种核心类型（重点）

C++11及以后，标准库提供了3种常用的智能指针，都定义在<memory>头文件中，各自有不同的使用场景，我们逐一讲解，重点掌握前两种。

1. std::unique_ptr：独占式智能指针（最常用、最高效）

unique_ptr的核心特点是独占所有权------同一时间，只能有一个unique_ptr对象指向同一块内存，不允许拷贝，只能通过移动（move）的方式转移所有权。

它是最轻量、效率最高的智能指针，性能几乎和原生指针一致，因为它没有额外的引用计数开销。

使用示例：

cpp 复制代码

#include <iostream>
#include <memory> // 必须包含头文件
using namespace std;

int main() {
    // 方式1：手动new（不推荐）
    unique_ptr<int> p1(new int(10));
    cout << *p1 << endl; // 输出10

    // 方式2：使用make_unique（推荐，更安全、高效）
    unique_ptr<int> p2 = make_unique<int>(20);
    cout << *p2 << endl; // 输出20

    // 错误：不能拷贝（unique_ptr不允许）
    // unique_ptr<int> p3 = p2; // 编译报错

    // 正确：移动所有权（p2失去所有权，p3获得所有权）
    unique_ptr<int> p3 = move(p2);
    // cout << *p2 << endl; // 错误，p2已悬空

    return 0; // 作用域结束，p1、p3自动析构，释放内存
}

适用场景：

对象只需要被一个地方持有（独占所有权）。
作为函数的返回值（无需担心内存泄漏，返回时自动转移所有权）。
容器中存储指针（避免拷贝，提升效率）。

2. std::shared_ptr：共享式智能指针（最灵活）

shared_ptr的核心特点是共享所有权------多个shared_ptr对象可以指向同一块内存，它内部维护了一个"引用计数"，用来记录当前有多少个指针指向这块内存。

当引用计数为0时，才会真正释放内存；每当有一个shared_ptr指向这块内存，引用计数加1；每当一个shared_ptr离开作用域，引用计数减1。

使用示例：

cpp 复制代码

#include <iostream>
#include <memory>
using namespace std;

int main() {
    // 方式1：make_shared（推荐）
    shared_ptr<int> p1 = make_shared<int>(100);
    cout << "引用计数：" << p1.use_count() << endl; // 输出1

    // 共享所有权，引用计数加1
    shared_ptr<int> p2 = p1;
    cout << "引用计数：" << p1.use_count() << endl; // 输出2

    // 共享所有权，引用计数加1
    shared_ptr<int> p3(p1);
    cout << "引用计数：" << p1.use_count() << endl; // 输出3

    // p2离开作用域，引用计数减1
    {
        shared_ptr<int> p4 = p1;
        cout << "引用计数：" << p1.use_count() << endl; // 输出4
    }
    cout << "引用计数：" << p1.use_count() << endl; // 输出3

    return 0; // p1、p2、p3离开作用域，引用计数依次减为0，内存释放
}

注意点：循环引用（shared_ptr的"坑"）

shared_ptr有一个致命的问题------循环引用，这会导致内存泄漏。比如：A对象持有B对象的shared_ptr，B对象持有A对象的shared_ptr，此时两者的引用计数永远都是2，即使离开作用域，引用计数也不会减到0，内存永远无法释放。

举个循环引用的反例：

cpp 复制代码

#include <iostream>
#include <memory>
using namespace std;

class B; // 前置声明

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

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

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

    a->b_ptr = b; // A持有B
    b->a_ptr = a; // B持有A

    return 0; // 没有输出析构信息，内存泄漏
}

解决循环引用的方案，就是下面要讲的weak_ptr。

3. std::weak_ptr：弱引用智能指针（解决循环引用）

weak_ptr是一种"弱引用"指针，它不拥有对象的所有权，也不会增加引用计数。它的作用是"观察"shared_ptr指向的对象，判断对象是否还存活，同时用来解决shared_ptr的循环引用问题。

weak_ptr不能直接访问对象，必须先通过lock()方法转换成shared_ptr，才能访问对象（这样可以保证访问时对象一定是存活的）。

解决循环引用示例：

cpp 复制代码

#include <iostream>
#include <memory>
using namespace std;

class B;

class A {
public:
    weak_ptr<B> b_ptr; // 改成weak_ptr
    ~A() { cout << "A被析构" << endl; }
};

class B {
public:
    weak_ptr<A> a_ptr; // 改成weak_ptr
    ~B() { cout << "B被析构" << endl; }
};

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

    a->b_ptr = b;
    b->a_ptr = a;

    return 0; // 输出A被析构、B被析构，内存正常释放
}

因为weak_ptr不增加引用计数，所以A和B的引用计数始终是1，离开作用域后，引用计数减为0，对象正常析构，循环引用被打破。

适用场景：

解决shared_ptr的循环引用问题。
观察者模式（观察者持有被观察者的弱引用，避免被观察者无法释放）。
缓存场景（缓存对象用shared_ptr管理，缓存引用用weak_ptr，避免缓存占用过多内存）。

四、3种智能指针对比（一目了然）

智能指针类型	所有权	是否可拷贝	是否有引用计数	核心用途	性能
unique_ptr	独占	否（仅可移动）	无	独享对象，高效管理	最高（接近原生指针）
shared_ptr	共享	是	有	多地方共享对象	中等（有引用计数开销）
weak_ptr	无	是	无	解决循环引用、观察对象	中等（依赖shared_ptr）

五、实战避坑技巧（面试高频）

掌握了智能指针的基本用法，还要注意这些细节，避免踩坑，同时也是面试常考的知识点：

优先使用make_unique/make_shared，而非直接new：make系列函数可以避免内存泄漏（比如new分配内存后，智能指针构造失败，会导致内存无法释放），同时更高效（make_shared会一次性分配内存，而直接new会分配两次内存：一次给对象，一次给引用计数）。
不要混用原生指针和智能指针：比如用原生指针接收智能指针的get()方法返回值，然后delete原生指针，会导致重复释放，程序崩溃。get()方法的作用只是获取原生指针，不能用来释放内存。
不要用auto_ptr：auto_ptr是C++98的智能指针，存在很多缺陷（比如拷贝时会转移所有权，容易导致悬空指针），C++17已正式删除，用unique_ptr替代。
shared_ptr不要指向栈内存：智能指针的析构函数会调用delete，而栈内存会自动释放，会导致重复释放，程序崩溃。
weak_ptr的expired()方法：可以判断weak_ptr观察的对象是否还存活，返回true表示对象已释放，false表示对象还存活。

六、总结

智能指针是C++内存管理的"神器"，核心是利用RAII机制自动释放内存，彻底解决原生指针的内存泄漏、重复释放等问题。

日常开发中，我们可以遵循这样的使用原则：

如果对象只需要被一个地方持有，优先用unique_ptr（高效、安全）。
如果对象需要被多个地方共享，用shared_ptr（灵活）。
如果遇到shared_ptr的循环引用，用weak_ptr解决。

掌握智能指针的用法和原理，不仅能提升代码的安全性和可读性，也是C++面试的必备知识点。希望这篇文章能帮你彻底搞懂智能指针，从此告别内存管理的烦恼！