C++ 智能指针原理、使用场景与避坑指南

2.2 自定义智能指针示例

基于 RAII 思想，我们可以实现一个简单的智能指针，重载指针操作符以模拟原生指针行为：

template<class T> 
class SmartPtr { 
public: 
    // 构造时获取资源
    SmartPtr(T* ptr) : _ptr(ptr) {} 
    // 析构时释放资源
    ~SmartPtr() { 
        cout << "delete[] " << _ptr << endl; 
        delete[] _ptr; 
    } 
    // 重载指针操作符，模拟原生指针
    T& operator*() { return *_ptr; } 
    T* operator->() { return _ptr; } 
    T& operator[](size_t i) { return _ptr[i]; } 
private: 
    T* _ptr; // 管理的资源指针
};

使用该智能指针重构 Func 函数，代码将大幅简化：

void Func() { 
    SmartPtr<int> sp1 = new int[10]; 
    SmartPtr<int> sp2 = new int[10]; 
    for (size_t i = 0; i < 10; i++) { 
        sp1[i] = sp2[i] = i; 
    } 
    int len, time; 
    cin >> len >> time; 
    cout << Divide(len, time) << endl; 
}

无论是否抛出异常，sp1和sp2析构时都会自动释放数组，彻底避免内存泄漏。

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

C++ 标准库在 <memory> 头文件中提供了 4 种智能指针，各自适用于不同场景，核心差异在于资源所有权管理策略。

3.1 auto_ptr（已废弃）

• 特性：C++98 引入的第一代智能指针，拷贝时转移资源所有权（被拷贝对象悬空）；
• 缺陷：设计缺陷导致访问悬空指针崩溃，C++11 后被强烈建议废弃；

示例：

auto_ptr<Date> ap1(new Date); 
auto_ptr<Date> ap2(ap1); // ap1 已悬空，后续访问 ap1->_year 会崩溃

3.2 unique_ptr（独占指针）

• 特性：C++11 引入，独占资源所有权，不支持拷贝，仅支持移动（move）；
• 适用场景：无需共享资源的场景（最常用的智能指针）；
• 关键特性：
  • 禁用拷贝构造和赋值运算符（= delete）；
  • 支持移动语义（std::move），移动后原对象悬空；
  • 特化支持 new[] 资源（unique_ptr<Date[]> up(new Date[5])）；

示例：

unique_ptr<Date> up1(new Date); 
// unique_ptr<Date> up2(up1); // 编译报错，不支持拷贝
unique_ptr<Date> up3(move(up1)); // 支持移动，up1 悬空

3.3 shared_ptr（共享指针）

• 特性：C++11 引入，支持资源共享，通过引用计数管理资源生命周期；
• 核心原理：
  • 堆上维护引用计数（多个对象共享同一计数）；
  • 拷贝时计数 + 1，析构时计数 - 1；
  • 计数为 0 时，释放资源；
• 适用场景：需要多个对象共享资源的场景；
• 关键特性：
  • 支持 make_shared 构造（更高效，避免内存碎片）；
  • 支持自定义删除器（处理非 new 分配的资源）；
  • 特化支持 new[] 资源；

示例：

shared_ptr<Date> sp1(new Date); 
shared_ptr<Date> sp2(sp1); // 拷贝，计数=2
shared_ptr<Date> sp3 = make_shared<Date>(2024, 9, 11); // 推荐构造方式
cout << sp1.use_count() << endl; // 输出 2

3.4 weak_ptr（弱指针）

• 特性：C++11 引入，不管理资源，仅作为 shared_ptr 的辅助工具；
• 核心作用：解决 shared_ptr 的循环引用问题；
• 关键特性：
  • 绑定 shared_ptr 时不增加引用计数；
  • 无 operator* 和 operator->，需通过 lock() 获取 shared_ptr 访问资源；
  • 支持 expired() 检查资源是否已释放；

示例：

shared_ptr<string> sp1 = make_shared<string>("hello"); 
weak_ptr<string> wp = sp1; // 计数仍为 1
if (!wp.expired()) { 
    shared_ptr<string> sp2 = wp.lock(); // 计数 +1
    cout << *sp2 << endl; 
}

3.5 自定义删除器

智能指针默认使用 delete 释放资源，若资源通过 new[]、fopen 等方式获取，需自定义删除器：

// 1. 仿函数删除器（释放 new[] 资源）
template<class T> class DeleteArray { 
public: 
    void operator()(T* ptr) { delete[] ptr; } 
}; 
// 2. lambda 删除器（释放文件句柄）
shared_ptr<FILE> sp5(fopen("test.cpp", "r"), [](FILE* ptr) { fclose(ptr); }); 
// 使用示例
shared_ptr<Date> sp2(new Date[5], DeleteArray<Date>()); 
unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);

四、智能指针的核心原理实现

4.1 unique_ptr 实现（核心：禁用拷贝）

template<class T> 
class unique_ptr { 
public: 
    explicit unique_ptr(T* ptr = nullptr) : _ptr(ptr) {} 
    // 移动构造
    unique_ptr(unique_ptr<T>&& sp) : _ptr(sp._ptr) { sp._ptr = nullptr; } 
    ~unique_ptr() { if (_ptr) delete _ptr; } 
    // 禁用拷贝构造和赋值
    unique_ptr(const unique_ptr<T>&) = delete; 
    unique_ptr<T>& operator=(const unique_ptr<T>&) = delete; 
    // 指针操作符重载
    T& operator*() { return *_ptr; } 
    T* operator->() { return _ptr; } 
private: 
    T* _ptr;
};

4.2 shared_ptr 实现（核心：引用计数）

template<class T> 
class shared_ptr { 
public: 
    explicit shared_ptr(T* ptr = nullptr) : _ptr(ptr), _pcount(new int(1)) {} 
    // 拷贝构造：计数 +1
    shared_ptr(const shared_ptr<T>& sp) : _ptr(sp._ptr), _pcount(sp._pcount) { ++(*_pcount); } 
    // 析构：计数 -1，为 0 则释放资源
    ~shared_ptr() { if (--(*_pcount) == 0) { delete _ptr; delete _pcount; } } 
    // 指针操作符重载
    T& operator*() { return *_ptr; } 
    T* operator->() { return _ptr; } 
    // 获取引用计数
    int use_count() const { return *_pcount; } 
private: 
    T* _ptr; // 管理的资源
    int* _pcount; // 引用计数（堆上分配）
    function<void(T*)> _del = [](T* p) { delete p; }; // 默认删除器
};

五、智能指针的常见问题与解决方案

5.1 shared_ptr 循环引用（致命问题）

问题场景

两个 shared_ptr 相互引用，导致引用计数无法归零，资源泄漏：

struct ListNode { 
    int _data; 
    shared_ptr<ListNode> _next; // 相互引用
    shared_ptr<ListNode> _prev; 
    ~ListNode() { cout << "~ListNode()" << endl; } 
}; 
int main() { 
    shared_ptr<ListNode> n1(new ListNode); 
    shared_ptr<ListNode> n2(new ListNode); 
    n1->_next = n2; // n2 计数=2
    n2->_prev = n1; // n1 计数=2
    // 析构时 n1 和 n2 计数均变为 1，资源无法释放
    return 0; 
}

解决方案

将相互引用的成员改为 weak_ptr（不增加引用计数）：

struct ListNode { 
    int _data; 
    weak_ptr<ListNode> _next; // 弱引用，不影响计数
    weak_ptr<ListNode> _prev; 
    ~ListNode() { cout << "~ListNode()" << endl; } 
};

5.2 shared_ptr 线程安全问题

问题说明

• 引用计数的增减操作不是原子的，多线程拷贝 / 析构 shared_ptr 会导致计数错乱；
• shared_ptr 指向的对象本身线程不安全，需手动加锁保护。

解决方案

• 引用计数使用原子类型（atomic<int>*）或加锁；
• 访问共享对象时，使用互斥锁（mutex）保护。

5.3 避免悬空指针

• unique_ptr 和 auto_ptr 移动后，原对象悬空，禁止后续访问；
• weak_ptr 需通过 expired() 检查资源状态，再通过 lock() 获取 shared_ptr 访问。

六、智能指针的最佳实践

1. 优先使用 unique_ptr：无需共享资源时，unique_ptr 效率最高（无引用计数开销）；
2. 共享资源用 shared_ptr：使用 make_shared 构造（比直接 new 更高效）；
3. 避免循环引用：相互引用的场景用 weak_ptr；
4. 自定义删除器：非 new 分配的资源（如 new[]、文件句柄）必须指定删除器；
5. 禁止隐式转换：shared_ptr 和 unique_ptr 的构造函数用 explicit 修饰，避免普通指针隐式转换；
6. 避免手动管理资源：尽量用智能指针替代 new/delete，从源头避免内存泄漏。

七、总结

智能指针是 C++ 内存管理的核心工具，其本质是 RAII 思想的实现。unique_ptr 和 shared_ptr 覆盖了绝大多数场景，weak_ptr 则解决了 shared_ptr 的循环引用问题。掌握智能指针的使用场景、原理和避坑要点，能大幅提升代码的安全性和可维护性。在实际开发中，应优先使用标准库智能指针，避免手动管理动态内存，从根本上杜绝内存泄漏。