在 C++ 编程中，动态内存管理始终是开发者面临的核心挑战之一。手动使用 new 分配内存、delete 释放内存的模式，不仅需要时刻关注内存生命周期，更可能因疏忽导致内存泄漏、二次释放，或是在异常抛出时跳过 delete 语句。这些隐患轻则导致性能退化，重则引发崩溃。
为解决这一痛点，C++ 标准库引入了智能指针。它基于'资源获取即初始化'（RAII）的设计思想，将动态内存资源封装为对象的成员，利用对象自动调用析构函数的特性，实现内存的'自动释放'，从根本上减少手动管理内存的负担与风险。
核心原理与基础实现
智能指针的核心在于 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;
};
使用时只需像普通指针一样：SmartPtr<string> sp(new string("renshen"));。但实际开发中，我们更需要的是标准库提供的几种类型，它们解决了拷贝、共享、循环引用等复杂场景。
标准库中的智能指针
std::auto_ptr (已废弃)
这是 C++98 时代的产物，原理是管理权的转移。在拷贝时，被拷贝对象的资源管理权会转移给拷贝对象，原对象变为空指针。这种机制容易导致悬空指针问题，很多公司明令禁止使用。
模拟实现要点：
template <class T>
class auto_ptr {
public:
auto_ptr(T* ptr) : _ptr(ptr) {}
~auto_ptr() { delete _ptr; }
// 拷贝构造函数中转移所有权
auto_ptr(auto_ptr<T>& ap) : _ptr(ap._ptr) { ap._ptr = nullptr; }
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
private:
T* _ptr;
};
std::unique_ptr
C++11 引入，代表独占所有权。它禁止拷贝和赋值，确保同一时间只有一个指针指向该资源。这既安全又高效，适用于不需要共享资源的场景。
模拟实现要点：
template <class T>
class unique_ptr {
public:
unique_ptr(T* ptr) : _ptr(ptr) {}
~unique_ptr() { delete _ptr; }
// 禁止拷贝和赋值
unique_ptr(unique_ptr<T>&&) = default;
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;
};
std::shared_ptr
这是最常用的智能指针，通过引用计数实现资源共享。多个 shared_ptr 可以指向同一对象，当引用计数归零时，资源才会被释放。需要注意的是，shared_ptr 存在循环引用的风险，此时需搭配 weak_ptr 使用。
模拟实现要点：
template <class T>
class shared_ptr {
public:
shared_ptr(T* ptr = nullptr) : _ptr(ptr), _pcount(new int(1)) {}
template <class D>
shared_ptr(T* ptr, D del) : _ptr(ptr), _pcount(new int(1)), _del(del) {}
~shared_ptr() {
if (--(*_pcount) == 0) {
_del(_ptr);
delete _pcount;
}
}
// 拷贝构造增加计数
shared_ptr(const shared_ptr<T>& sp) : _ptr(sp._ptr), _pcount(sp._pcount) {
++(*_pcount);
}
// 赋值操作
shared_ptr<T>& operator=(const shared_ptr<T>& sp) {
if (_ptr == sp._ptr) return *this;
if (--(*_pcount) == 0) {
_del(_ptr);
delete _pcount;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
return *this;
}
T* get() const { return _ptr; }
private:
T* _ptr;
int* _pcount;
std::function<void(T*)> _del = [](T* ptr){ delete ptr; };
};
shared_ptr 的一个弊端
当两个 shared_ptr 互相持有对方时，引用计数永远无法归零，导致内存泄漏。这就是著名的循环引用问题。
std::weak_ptr
weak_ptr 不参与资源管理，不增加引用计数，专门用于解决 shared_ptr 的循环引用问题。它可以访问资源，但不能直接释放。
模拟实现要点：
template <class T>
class weak_ptr {
public:
weak_ptr() : _ptr(nullptr) {}
weak_ptr(const shared_ptr<T>& sp) : _ptr(sp.get()) {}
weak_ptr<T>& operator=(const shared_ptr<T>& sp) {
_ptr = sp.get();
return *this;
}
T* get() const { return _ptr; }
private:
T* _ptr;
};
删除定制器
在使用智能指针时，可能会遇到 new[] 或 malloc 出来的空间，直接用 delete 会导致未定义行为。此时需要自定义删除器（Deleter）。标准库的 unique_ptr 和 shared_ptr 都支持传入自定义删除函数，例如用 std::vector 的析构逻辑来清理数组。
总结
掌握智能指针的关键在于理解所有权模型：unique_ptr 独占，shared_ptr 共享，weak_ptr 辅助打破循环。在实际编码中，优先使用 unique_ptr，仅在必要时使用 shared_ptr，并时刻警惕循环引用陷阱。
