C++智能指针全面解析：原理、使用场景与最佳实践

[一、智能指针的诞生背景](#一、智能指针的诞生背景)

二、RAII设计理念

三、C++标准库智能指针详解

[3.1 auto_ptr（已废弃）](#3.1 auto_ptr（已废弃）)

[3.2 unique_ptr](#3.2 unique_ptr)

[3.3 shared_ptr](#3.3 shared_ptr)

[3.4 weak_ptr](#3.4 weak_ptr)

四、智能指针的原理

[五. shared_ptr和weak_ptr](#五. shared_ptr和weak_ptr)

[5.1 shared_ptr循环引用问题](#5.1 shared_ptr循环引用问题)

[5.2 weak_ptr解决方案](#5.2 weak_ptr解决方案)

[六、智能指针的线程安全性](#六、智能指针的线程安全性)

[6.1 引用计数的线程安全](#6.1 引用计数的线程安全)

[6.2 对象访问的线程安全](#6.2 对象访问的线程安全)

[七、 C++11和boost中智能指针的关系](#七、 C++11和boost中智能指针的关系)

[八、内存泄漏检测与预防](#八、内存泄漏检测与预防)

[8.1 什么是内存泄漏，内存泄漏的危害](#8.1 什么是内存泄漏，内存泄漏的危害)

8.2工具推荐

[8.3 预防策略](#8.3 预防策略)

[九、总结](#九、总结)

一、智能指针的诞生背景

下面程序中我们可以看到，new了以后，我们也delete了，但是因为抛异常，后面的delete没有得到执行，所以就内存泄漏了，所以我们需要new以后捕获异常，捕获到异常后delete内存，再把异常抛出，但是因为new本身也可能抛异常，连续的两个new和下面的Divide都可能会抛异常，让我们处理起来很麻烦。智能指针放到这样的场景里面就让问题简单多了。

cpp 复制代码

double Divide(int a, int b) {
    if (b == 0) {
        throw "Divide by zero condition!";
    }
    return static_cast<double>(a) / b;
}

void Func() {
    int* array1 = new int[10];
    int* array2 = new int[10];
    
    try {
        int len, time;
        std::cin >> len >> time;
        std::cout << Divide(len, time) << std::endl;
    } catch (...) {
        // 异常发生时，array1和array2可能无法被释放
        delete[] array1;
        delete[] array2;
        throw;
    }
    
    delete[] array1;
    delete[] array2;
}

问题分析：

如果第二个new操作抛出异常，array1将无法被释放
如果Divide函数抛出异常，需要在每个catch块中手动释放所有资源
代码冗余且容易遗漏释放操作

二、RAII设计理念

RAII是Resource Acquisition Is Initialization的缩写，它是一种管理资源的类的设计思想，本质是⼀利用对象生命周期来管理获取到的动态资源，避免资源泄漏。这⾥的资源可以是内存、文件指针、网络连接、互斥锁等等。RAII在获取资源时把资源委托给一个对象，接着控制对资源的访问，资源在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源，这样保障了资源的正常释放，避免资源泄漏问题。

RAII（Resource Acquisition Is Initialization）是C++资源管理的核心思想：

cpp 复制代码

template<class T>
class SmartPtr {
public:
    // RAII：构造函数获取资源
    SmartPtr(T* ptr) : _ptr(ptr) {}
    
    // RAII：析构函数释放资源
    ~SmartPtr() {
        std::cout << "delete[] " << _ptr << std::endl;
        delete[] _ptr;
    }
    
    // 重载运算符，模拟指针行为
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    T& operator[](size_t i) { return _ptr[i]; }
    
private:
    T* _ptr;
};

RAII的优势：

资源生命周期与对象生命周期绑定
异常安全：栈展开时自动调用析构函数
代码简洁：无需手动管理资源释放

三、C++标准库智能指针详解

C++标准库中的智能指针都在<memory>这个头文件下面，我们包含<memory>就可以使用了。智能指针有好几种，除了weak_ptr，它们都符合RAII和像指针一样访问的行为，原理上而言主要是解决智能指针拷贝时的思路不同。

3.1 auto_ptr（已废弃）

auto_ptr是C++98时设计出来的智能指针，它的特点是拷贝时把被拷贝对象的资源的管理权转移给拷贝对象，这是一个非常糟糕的设计，因为它会导致被拷贝对象悬空，出现访问报错的问题。C++11设计出新的智能指针后，强烈建议不要使用auto_ptr。其他C++11出来之前，很多公司也是明令禁止使用这个智能指针的。

cpp 复制代码

// C++98引入，存在设计缺陷
std::auto_ptr<Date> ap1(new Date);
std::auto_ptr<Date> ap2(ap1); // 管理权转移，ap1变为空指针

问题：拷贝语义不明确，容易导致悬空指针。

3.2 unique_ptr

unique_ptr是C++11设计出来的智能指针，它的名字翻译出来是唯一指针，它的特点是不支持拷贝，只支持移动。如果不需要拷贝的场景就非常建议使用它。

cpp 复制代码

// 独占所有权，不支持拷贝，支持移动
std::unique_ptr<Date> up1(new Date);
// std::unique_ptr<Date> up2(up1); // 编译错误
std::unique_ptr<Date> up3(std::move(up1)); // 支持移动语义

特性：

零开销抽象
支持自定义删除器
数组特化版本：unique_ptr<T[]>

3.3 shared_ptr

shared_ptr是C++11设计出来的智能指针，它的名字翻译出来是共享指针，它的特点是支持拷贝，也支持移动。如果需要拷贝的场景就需要使用它了。底层是用引用计数的方式实现的。

cpp 复制代码

// 共享所有权，引用计数
std::shared_ptr<Date> sp1(new Date);
std::shared_ptr<Date> sp2(sp1); // 引用计数+1
std::cout << sp1.use_count() << std::endl; // 输出：2

实现原理：

cpp 复制代码

template<class T>
class shared_ptr {
public:
    shared_ptr(T* ptr = nullptr) 
        : _ptr(ptr), _pcount(new int(1)) {}
    
    shared_ptr(const shared_ptr<T>& sp)
        : _ptr(sp._ptr), _pcount(sp._pcount) {
        ++(*_pcount);
    }
    
    ~shared_ptr() {
        if (--(*_pcount) == 0) {
            delete _ptr;
            delete _pcount;
        }
    }
    
private:
    T* _ptr;
    int* _pcount; // 引用计数
};

3.4 weak_ptr

weak_ptr是C++11设计出来的智能指针，它的名字翻译出来是"弱指针"，它完全不同于上面的智能指针，它不支持RAII，也就意味着不能用它直接管理资源。weak_ptr的产生本质是要解决shared_ptr的一个循环引用导致内存泄漏的问题。

cpp 复制代码

// 不增加引用计数，解决循环引用问题
std::shared_ptr<Date> sp(new Date);
std::weak_ptr<Date> wp = sp;

if (auto shared = wp.lock()) { // 尝试获取shared_ptr
    // 安全使用资源
}

智能指针性能对比

智能指针类型	拷贝开销	线程安全	适用场景
unique_ptr	零开销	是	独占所有权，性能敏感
shared_ptr	引用计数原子操作	引用计数安全	共享所有权
weak_ptr	低开销	是	打破循环引用

四、智能指针的原理

下面我们模拟实现了auto_ptr和unique_ptr的核心功能，这两个智能指针的实现比较简单，大家了解一下原理即可。auto_ptr的思路是拷贝时转移资源管理权给被拷贝对象，这种思路是不被认可的，也不建议使用。unique_ptr的思路是不支持拷贝。
大家重点要看看shared_ptr是如何设计的，尤其是引用计数的设计，主要这里一份资源就需要一个引用计数，所以引用计数才用静态成员的方式是无法实现的，要使用堆上动态开辟的方式，构造智能指针对象时来一份资源，就要new一个引用计数出来。多个shared_ptr指向资源时就++引用计数，shared_ptr对象析构时就--引用计数，引用计数减到0时代表当前析构的shared_ptr是最后一个管理资源的对象，则析构资源。

cpp 复制代码

// 函数指针作为删除器
template<class T>
void DeleteArray(T* ptr) {
    delete[] ptr;
}

// 仿函数作为删除器
template<class T>
struct DeleteArray {
    void operator()(T* ptr) {
        delete[] ptr;
    }
};

// Lambda表达式作为删除器
auto del = [](Date* ptr) { delete[] ptr; };

// 使用示例
std::unique_ptr<Date, DeleteArray<Date>> up1(new Date[5]);
std::shared_ptr<Date> sp1(new Date[5], DeleteArray<Date>());
std::unique_ptr<Date, decltype(del)> up2(new Date[5], del);

五. shared_ptr和weak_ptr

5.1 shared_ptr循环引用问题

shared_ptr大多数情况下管理资源非常合适，支持RAII，也支持拷贝。但是在循环引用的场景下会导致资源没得到释放内存泄漏，所以我们要认识循环引用的场景和资源没释放的原因，并且学会使用weak_ptr解决这种问题。
如下图所述场景，n1和n2析构后，管理两个节点的引用计数减到1

右边的节点什么时候释放呢，左边节点中的_next管着呢，_next析构后，右边的节点就释放了。
_next什么时候析构呢，_next是左边节点的成员，左边节点释放，_next就析构了。
左边节点什么时候释放呢，左边节点由右边节点中的_prev管着呢，_prev析构后，左边的节点就释放了。
_prev什么时候析构呢，_prev是右边节点的成员，右边节点释放，_prev就析构了。

至此逻辑上成功形成回旋镖似的循环引用，谁都不会释放就形成了循环引用，导致内存泄漏。
把ListNode结构体中的_next和_prev改成weak_ptr，weak_ptr绑定到shared_ptr时不会增加它的
引用计数，_next和_prev不参与资源释放管理逻辑，就成功打破了循环引用，解决了这里的问题。

5.2 weak_ptr解决方案

weak_ptr不支持RAII，也不支持访问资源，所以我们看文档发现weak_ptr构造时不支持绑定到资源，只支持绑定到shared_ptr，绑定到shared_ptr时，不增加shared_ptr的引用计数，那么就可以解决上述的循环引用问题。
weak_ptr也没有重载operator*和operator->等，因为它不参与资源管理，那么如果它绑定的shared_ptr已经释放了资源，那么它去访问资源就是很危险的。weak_ptr支持expired检查指向的资源是否过期，use_count也可获取shared_ptr的引用计数，weak_ptr想访问资源时，可以调用lock返回一个管理资源的shared_ptr，如果资源已经被释放，返回的shared_ptr是一个空对象，如果资源没有释放，则通过返回的shared_ptr访问资源是安全的。

cpp 复制代码

struct ListNode {
    int data;
    std::shared_ptr<ListNode> next;
    std::weak_ptr<ListNode> prev; // 使用weak_ptr打破循环
    
    ~ListNode() {
        std::cout << "~ListNode()" << std::endl;
    }
};

循环引用原理图示：

六、智能指针的线程安全性

6.1 引用计数的线程安全

shared_ptr的拷析构时会访问修改引用计数，就会存在线程安全问题，所以`shared_ptr`引用计数是需要加锁或者原子操作保证线程安全的。
shared_ptr指向的对象也是有线程安全的问题的，但是这个对象的线程安全问题不归`shared_ptr`管，它也管不了，应该有外层使用`shared_ptr`的⼈进⾏线程安全的控制。
下面的程序会崩溃或者A资源没释放，`std::shared_ptr`引⽤计数从`int*`改成`atomic<int>*`就可以保证引用计数的线程安全问题，或者使用互斥锁加锁也可以。

cpp 复制代码

// shared_ptr引用计数是线程安全的
std::shared_ptr<AA> p(new AA);

auto func = [&]() {
    for (size_t i = 0; i < 1000000; ++i) {
        std::shared_ptr<AA> copy(p); // 引用计数操作线程安全
        // 但对象访问需要额外同步
    }
};

std::thread t1(func);
std::thread t2(func);
t1.join();
t2.join();

6.2 对象访问的线程安全

在多线程编程环境中，保证对象访问的线程安全是至关重要的。当多个线程同时访问和修改共享对象时，如果没有适当的同步机制，可能会导致数据不一致、竞态条件等问题。以下是保证对象访问线程安全的关键要点：

同步机制
- 使用synchronized关键字：可以通过同步方法或同步代码块来实现
  - 实例方法同步：对整个方法加锁，锁对象是当前实例
  - 静态方法同步：锁对象是类的Class对象
  - 同步代码块：可以指定特定的锁对象
- 使用Lock接口及其实现类（如ReentrantLock）
  - 提供更灵活的锁操作
  - 支持公平锁和非公平锁
  - 支持tryLock()等高级功能
线程安全的数据结构
- Java集合框架中的线程安全版本：
  - ConcurrentHashMap
  - CopyOnWriteArrayList
  - ConcurrentLinkedQueue
- 原子类：
  - AtomicInteger
  - AtomicLong
  - AtomicReference
不可变对象
- 通过final关键字修饰类和字段
- 不提供修改内部状态的方法
- 典型示例：String类
线程封闭
- 栈封闭：将对象限制在方法内部使用
- ThreadLocal：为每个线程创建独立的变量副本
最佳实践
- 尽量减少同步范围
- 避免锁嵌套
- 注意死锁问题
- 考虑使用无锁算法

示例场景：

cpp 复制代码

struct AA {
    int a1 = 0;
    int a2 = 0;
    std::mutex mtx;
};

void thread_safe_access() {
    std::shared_ptr<AA> p(new AA);
    
    auto func = [&]() {
        for (size_t i = 0; i < 1000000; ++i) {
            auto copy = p; // 安全的引用计数操作
            std::lock_guard<std::mutex> lock(copy->mtx);
            copy->a1++;
            copy->a2++;
        }
    };
}

七、 C++11和boost中智能指针的关系

Boost库是为C++语⾔标准库提供扩展的⼀些C++程序库的总称，Boost社区建⽴的初衷之⼀就是为C++的标准化工作提供可供参考的实现，Boost社区的发起人Dawes本人就是C++标准委员会的成员之一。在Boost库的开发中，Boost社区也在这个方向上取得了丰硕的成果，C++11及之后的新语法和库有很多都是从Boost中来的。
C++ 98中产生了第一个智能指针auto_ptr。
C++ boost给出了更实用的scoped_ptr/scoped_array、shared_ptr/shared_array和weak_ptr等。
C++ TR1引入了shared_ptr等，不过要注意的是TR1并不是标准版。
C++ 11引入了unique_ptr、shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的 scoped_ptr，并且这些智能指针的实现原理是参考boost中的实现的。

八、内存泄漏检测与预防

8.1 什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存，一般是忘记释放或者发生异常释放而程序未能执行导致的。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：普通程序运行一会就结束了，出现内存泄漏问题也不大，进程正常结束，页表的映射关系解除，物理内存也可以释放。长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务、长时间运行的客户端等等，不断出现内存泄漏会导致可用内存不断变少，各种功能响应越来越慢，最终卡死。

8.2工具推荐

Windows : Visual Leak Detector (VLD)
Linux : Valgrind, AddressSanitizer
跨平台: Clang Static Analyzer

8.3 预防策略

事前预防：全面使用智能指针
编码规范：遵循RAII原则
代码审查：定期检查资源管理
自动化测试：使用检测工具集成到CI/CD

九、总结

C++智能指针是现代C++编程中不可或缺的工具，它们：

自动化资源管理 ：避免手动new/delete带来的错误
提供异常安全：确保资源在异常情况下正确释放
支持多种所有权语义：满足不同场景需求
具备良好的性能：多数情况下接近手动管理的效率

通过合理运用unique_ptr、shared_ptr和weak_pt，开发者可以构建出既安全又高效的C++应用程序，从根本上解决内存泄漏和资源管理问题。

参考资料：

C++ Standard Library Documentation
Scott Meyers, "Effective Modern C++"
Bjarne Stroustrup, "The C++ Programming Language"
ISO/IEC 14882:2020 (C++20 Standard)

C++智能指针全面解析：原理、使用场景与最佳实践

一、 智能指针的诞生背景

二、RAII设计理念

三、C++标准库智能指针详解

3.1 auto_ptr（已废弃）

3.2 unique_ptr

3.3 shared_ptr

3.4 weak_ptr

四、智能指针的原理

五. shared_ptr和weak_ptr

5.1 shared_ptr循环引用问题

5.2 weak_ptr解决方案

六、 智能指针的线程安全性

6.1 引用计数的线程安全

6.2 对象访问的线程安全

七、 C++11和boost中智能指针的关系

八、 内存泄漏检测与预防

8.1 什么是内存泄漏，内存泄漏的危害

8.2工具推荐

8.3 预防策略

九、 总结

一、智能指针的诞生背景

六、智能指针的线程安全性

八、内存泄漏检测与预防

九、总结