C++八股——智能指针

1. 背景

智能指针不是指针，是一个管理指针的类，用来存储指向动态分配对象的指针，负责自动释放动态分配的对象，防止堆内存泄漏和悬空指针等问题。

动态分配的资源，交给一个类对象去管理，当类对象声明周期结束时，自动调用析构函数释放资源。

• C++ 98中产生第一个智能指针auto_ptr
• C++ 11起提供三个主要的智能指针，位于<memory>头文件中：
  • std::unique_ptr
  • std::shared_ptr
  • std::weak_ptr

关键特性对比

类型	所有权	复制语义	线程安全	性能开销
unique_ptr	独占	移动转移	单线程安全	无
shared_ptr	共享	允许复制	引用计数原子化	较高
weak_ptr	无所有权	允许复制	依赖关联shared	低

2. 原理与使用

智能指针的基本原理是利用RAII，在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在 对象析构的时候释放资源（不需要显式地释放资源）。

如果只是简单地用类封装指针，如：

template<class T>
class Smartptr
{
public:Smartptr(T* ptr) : _ptr(ptr) {}~Smartptr() {delete _ptr;}T& operator*() {return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

会出现拷贝问题：用一个智能指针赋值给另一个指针指针时，因为是浅拷贝，会将两个指针指向同一块内存，在程序结束析构智能指针时释放两次空间，导致程序崩溃。

为了解决这个问题，出现以下四类智能指针：

2.1 auto_ptr

原理：

管理权转移，被拷贝对象把资源管理权转移给拷贝对象，导致被拷贝对象悬空。保证了一个资源只有一个对象对其进行管理，这时候一个资源就不会被多个释放。

使用：

auto_ptr<int> ap1(new int(1));
auto_ptr<int> ap2(ap1);
// 此时ap1悬空

模拟实现：

template<class T>
class auto_ptr 
{
public:auto_ptr(T* ptr) : _ptr(ptr) {}auto_ptr(const auto_ptr<T>& ap) {_ptr = ap._ptr;ap._ptr = nullptr;}auto_ptr<T>& operator=(const auto_ptr<T>& ap) {// 检测是否自己给自己赋值if(this != &ap) {// 释放当前资源if(_ptr) delete _ptr;_ptr = ap._ptr;ap._ptr = nullptr;}return *this;}~auto_ptr() {delete _ptr;}T& operator*() {return *_ptr;}T* operator->() {return _ptr;}
private:T* _ptr;
};

2.2 unique_ptr

原理：

通过删除拷贝构造函数/赋值运算符来防止拷贝

使用：

unique_ptr<int> up0 = make_unique<int>(0);
unique_ptr<int> up1(new int(1));
unique_ptr<int> up2(new int(2));
sp1 = sp2; // 报错

在函数返回unique_ptr时不要返回其引用：

auto getUnique() {auto ptr = std::make_unique<int>(10);return ptr;  // 正确：移动语义转移所有权
}// auto& getUniqueRef() { ... }  // 错误：返回引用会导致悬空指针

模拟实现：

template<class T>
class unique_ptr 
{
public:unique_ptr(T* ptr) : _ptr(ptr) {}unique_ptr(const unique_ptr<T>& up) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& ap) = delete;~unique_ptr() {delete _ptr;}T& operator*() {return *_ptr;}T* operator->() {return _ptr;}
private:T* _ptr;
};

2.3 shared_ptr

原理：

通过引用计数的方式解决智能指针的拷贝问题：

• shared_ptr给每个资源都维护了着一份计数用来记录该份资源被几个对象共享；
• 在对象被销毁时(也就是析构函数调用)，引用计数减一；
• 如果引用计数是0，就说明自己是最后一个使用该资源的对象，就可以释放该资源；
• 如果引用计数不是0，就说明还有其他对象在使用该份资源，不能释放该资源。

使用：

shared_ptr<int> sp1(new int(1));
cout << sp1.use_count() << endl; // 1
shared_ptr<int> sp2(sp1);
cout << sp2.use_count() << endl; // 2

注意：避免混用裸指针与智能指针

int* raw = new int(5);
std::shared_ptr<int> p1(raw);
std::shared_ptr<int> p2(raw);  // 双重释放！

模拟实现：

template<class T>
class shared_ptr
{
public:shared_ptr(T* ptr) : _ptr(ptr), _pcount(new int(1)) {}~shared_ptr(){Release();}shared_ptr(const shared_ptr<T>& sp){_ptr = sp._ptr;_pcount = sp._pcount;  ++(*_pcount);}void Release() {if (--(*_pcount) == 0) {delete _pcount;delete _ptr;}}shared_ptr<T>& operator=(const shared_ptr<T>& sp) {//资源地址不一样if (_ptr != sp._ptr) {Release();_pcount = sp._pcount;_ptr = sp._ptr;++(*_pcount);}return *this;}int use_count() {return *_pcount;}// 像指针一样T& operator*() {return *_ptr;}T* operator->() {return _ptr;}T& operator[](size_t pos) {return _ptr[pos];}
private:T* _ptr;int* _pcount;
};

为什么引用计数要用指针，而不用成员变量或者静态成员变量？

1. 若将引用计数作为普通成员变量：不同 shared_ptr 副本之间无法共享计数（成员变量属于对象，而非资源）。

2. 静态变量（static）的特性：

   • 属于类本身，所有对象共享同一个静态变量。
   • 生命周期与程序一致，无法动态创建或销毁。
   • 全局唯一性，无法为每个资源单独维护计数。

   这与智能指针的资源独立性要求直接冲突：每个 shared_ptr 需要为其管理的资源单独维护引用计数，而静态变量会导致所有资源共享同一个计数器，引发严重错误。

   如果使用静态变量来计数，以下代码会出现错误：

   int main() {int* a = new int(10);int* b = new int(20);BadSharedPtr p1(a);  // count=1BadSharedPtr p2(b);  // count=2（错误！两个资源共享同一个计数器）p1.~BadSharedPtr();  // count=1（但 a 未被删除）p2.~BadSharedPtr();  // count=0，错误地删除 b，而 a 泄漏！return 0;
   }
   // 结果：a 内存泄漏，b 被提前释放，且程序崩溃。
   

循环引用问题：

class Node;class Parent {
public:std::shared_ptr<Node> child;  // Parent 持有 Node 的 shared_ptr~Parent() { std::cout << "Parent destroyed\n"; }
};class Node {
public:std::shared_ptr<Parent> parent;  // Node 也持有 Parent 的 shared_ptr（循环引用）~Node() { std::cout << "Node destroyed\n"; }
};int main() {auto parent = std::make_shared<Parent>();  // parent 引用计数 = 1auto node = std::make_shared<Node>();      // node 引用计数 = 1parent->child = node;    // node 引用计数 +1 → 2node->parent = parent;   // parent 引用计数 +1 → 2return 0;// main 结束时：// parent 引用计数 -1 → 1 → Parent 未被销毁！// node 引用计数 -1 → 1 → Node 未被销毁！
}

2.4 weak_ptr

原理：

观察但不拥有资源，用于解决shared_ptr循环引用问题。

使用：

• 解决shared_ptr循环引用问题：

  #include <memory>class Node;  // 前置声明class Parent {
  public:std::shared_ptr<Node> child;~Parent() { std::cout << "Parent destroyed\n"; }
  };class Node {
  public:// std::shared_ptr<Parent> parent;  // 循环引用导致内存泄漏std::weak_ptr<Parent> parent;      // 改用 weak_ptr 解决~Node() { std::cout << "Node destroyed\n"; }
  };int main() {auto parent = std::make_shared<Parent>(); // parent 引用计数 = 1auto node = std::make_shared<Node>();     // node 引用计数 = 1parent->child = node;   // node 引用计数 +1 → 2node->parent = parent;  // weak_ptr 不会增加引用计数return 0;  // 正确析构// main 结束时：// parent 引用计数 -1 → 0 → Parent 销毁 → child 销毁 → node 引用计数 -1  → 1// node 引用计数 -1 → 0 → Node 销毁！
  }
  

• 安全访问共享资源：

  #include <memory>
  #include <iostream>class Data {
  public:void process() { std::cout << "Processing data...\n"; }
  };int main() {std::shared_ptr<Data> sharedData = std::make_shared<Data>();std::weak_ptr<Data> weakData = sharedData;// 检查 weak_ptr 是否有效if (auto tmp = weakData.lock()) {  // 提升为 shared_ptrtmp->process();  // 安全使用std::cout << "Use count: " << tmp.use_count() << "\n";  // 输出 2} else {std::cout << "Data expired\n";}sharedData.reset();  // 释放资源if (weakData.expired()) {std::cout << "Data is no longer available\n";}return 0;
  }
  

模拟实现：

template<class T>
class weak_ptr
{
public:weak_ptr() :_ptr(nullptr) {}weak_ptr(const shared_ptr<T>& wp) {_ptr = wp.get();}weak_ptr<T>& operator=(const shared_ptr<T>& wp) {_ptr = wp.get();return *this;}T& operator*() {return *_ptr;}T* operator->() {return _ptr;}
private:T* _ptr;
};

2.5 定制删除器

定制删除器可以解决：如何正确释放用new或者new []开辟的资源。

template<class U, class D> unique_ptr(U* p, D del);

其中Del参数是一个定制删除器，是一个可调用对象，比如函数指针、仿函数、lambda表达式以及被包装器包装后的可调用对象。

// unique_ptr 自定义删除器
auto del = [](int* p) { delete[] p; };
std::unique_ptr<int[], decltype(del)> arr(new int[10], del);

参考：

• C++智能指针详解-CSDN博客
• DeepSeek