1、引言
在 C++ 编程中，内存管理历来是复杂且容易出错的部分。手动管理动态分配的内存不仅会导致内存泄漏，还会引发悬空指针和双重释放等问题。如何有效地管理动态内存，避免内存泄漏和未定义行为，往往是困扰初学者和资深开发者的难题。为了解决这些问题，C++ 逐步引入了智能指针。智能指针通过 RAII 模式实现自动化的内存管理，使开发者能更加专注于业务逻辑，而非担心内存的分配与释放。
智能指针包括了 std::unique_ptr、std::shared_ptr 和 std::weak_ptr 三种主要类型，它们分别解决了不同场景下的内存管理问题。接下来我们将逐步深入，探讨智能指针的演变历程、实现细节以及它们的应用场景。
智能指针的核心思想是利用 RAII（Resource Acquisition Is Initialization）模式来管理资源的生命周期，确保动态分配的对象在不再使用时自动释放。智能指针包括了 std::unique_ptr、std::shared_ptr 和 std::weak_ptr 三种主要类型，它们分别解决了不同场景下的内存管理问题。接下来我们将逐步深入，探讨智能指针的演变历程、实现细节以及它们的应用场景。
2、智能指针的演变历程
2.1、手动内存管理时代
在早期的 C 和 C++ 编程中，动态内存的分配和释放依赖开发者手动管理，通常通过 new 和 delete 来进行操作。例如：
int* ptr = new int(10);
// ...
delete ptr;
尽管这种方式看似简单，但它对开发者提出了严格的要求，即确保每次分配的内存都被正确释放。如果程序执行路径出现异常或者疏忽，未能释放的内存将造成内存泄漏。此外，重复释放同一个指针也会导致程序崩溃，增加了调试的复杂性。
2.2、智能指针的基本概念
智能指针的概念源自于传统指针的不足。普通指针指向堆上的动态内存，但需要手动管理对象的释放。如果开发者忘记释放内存或者多次释放内存，便会导致内存泄漏和未定义行为。而智能指针则将内存管理交给 C++ 的自动化机制来处理。
RAII (Resource Acquisition Is Initialization) 是一种利用对象生命周期来控制程序资源，在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效, 最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这样做法有两大好处：
- 不需要显示的释放资源
- 采用这种方式，对象所需的资源在其生命周期内始终保持有效
namespace Lenyiin
{
template <class T>
class Smart_ptr
{
public:
Smart_ptr(T *ptr)
: _ptr(ptr)
{
std::cout << "create: " << _ptr << std::endl;
}
~Smart_ptr()
{
if (_ptr)
{
std::cout << "delete: " << _ptr << std::endl;
delete _ptr;
}
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
}
通过使用类的特性，可以让指针在生命周期内和原生指针一样，在生命周期外通过析构函数自动释放。
int main()
{
// 智能指针 意义
// 无论是在函数正常结束, 还是抛异常, 都会导致 sp 对象的生命周期到了以后, 调用析构函数
std::cout << "---- 智能指针之前 ----" << std::endl;
{
Smart_ptr<int> sp1(new int);
*sp1 = 10;
Smart_ptr<std::pair<int, int>> sp2(new std::pair<int, int>);
sp2->first = 20;
sp2->second = 30;
}
std::cout << "---- 智能指针之后 ----" << std::endl;
return 0;
}
运行结果：
但是单纯的利用对象生命周期来控制程序资源，会产生严重的问题。
int main()
{
Smart_ptr<int> sp1(new int);
Smart_ptr<int> sp2 = sp1; // error 浅拷贝, 重复析构, 析构两次, 导致同一块内存被释放两次
return 0;
}
可能有人会有疑问，为什么智能指针不像 string、vector 等容器一样进行深拷贝？这是因为：智能指针只是托管资源空间，可以访问空间，模拟的是原生指针的行为，只是比原生指针多的是，可以在生命周期结束时自动释放资源。
由这个问题，衍生出了三种解决的方法：
- 管理权转移
auto_ptr - 防拷贝
unique_ptr - 引用计数
shared_ptr
2.3、C++98 和 auto_ptr 的引入
为了解决内存管理问题，C++98 引入了 auto_ptr，这是 C++ 最早期的智能指针，旨在简化动态内存的管理。
auto_ptr 的语法与其他智能指针类似，它封装了一个普通的指针，并在 auto_ptr 对象的生命周期结束时自动调用 delete，释放动态分配的内存。然而，auto_ptr 存在一些严重的缺陷，例如它使用复制语义来转移所有权，这在共享资源的场景下极不安全。
std::auto_ptr<int> ptr1(new int(10));
std::auto_ptr<int> ptr2 = ptr1; // ptr1 不再拥有资源
在上述代码中，ptr1 的所有权被转移到 ptr2，导致 ptr1 失去对对象的控制。这种设计使得 auto_ptr 在实际开发中较为不便，因此在 C++11 中被弃用。
2.4、C++11 引入 unique_ptr、shared_ptr、weak_ptr
随着 C++11 的到来，新的智能指针 unique_ptr、shared_ptr 和 weak_ptr 被引入，取代了 auto_ptr。它们通过现代 C++ 的移动语义、引用计数等机制，解决了 auto_ptr 的缺陷，并提供了更加安全、灵活的内存管理方式。
unique_ptr 提供了独占所有权，避免了不必要的资源共享问题；shared_ptr 支持多对象共享同一资源，并通过引用计数控制资源释放；而 weak_ptr 则帮助开发者避免循环引用的问题。
3、auto_ptr ：所有权转移智能指针
auto_ptr 是 C++98 标准中引入的智能指针，旨在通过 RAII 自动管理动态分配的内存。尽管它为 C++ 提供了自动化的内存管理机制，但由于其设计中的一些缺陷，后来被 unique_ptr 所取代，并最终在 C++11 中被标记为废弃（deprecated），在 C++17 中被完全移除。
虽然 auto_ptr 已经被遗弃了，为了帮助理解 auto_ptr 的历史、设计、缺陷，以及为什么最终被废弃，本章我们将对其进行详细的讨论。
3.1、auto_ptr 的引入
auto_ptr 是 C++98 标准库中的一种智能指针，设计的目的是帮助程序员自动释放动态分配的内存，避免常见的内存泄漏问题。在早期的 C++ 中，手动管理内存（通过 new 和 delete）常常会引发严重的内存管理问题，特别是在异常处理和多分支逻辑中，程序员容易忘记释放内存。
3.1.1、auto_ptr 的使用
auto_ptr 的语法与其他智能指针类似，它封装了一个普通的指针，并在 auto_ptr 对象的生命周期结束时自动调用 delete，释放动态分配的内存。
简单的 auto_ptr 使用示例：
#include <memory>
#include <iostream>
int main() {
std::auto_ptr<int> ptr(new int(10)); // 分配内存并初始化
std::cout << *ptr << std::endl; // 输出: 10
// 离开作用域时，ptr 自动释放所指向的内存
return 0;
}
在上面的例子中，auto_ptr 封装了一个动态分配的 int，当 ptr 离开作用域时，它会自动释放内存，不需要手动调用 delete。
3.1.2 auto_ptr 的工作原理
auto_ptr 的基本原理是通过 RAII（Resource Acquisition Is Initialization）来管理资源。它在构造时接管动态分配的内存，并在析构时自动调用 delete。这样可以确保即使发生异常，内存也能被正确释放，减少内存泄漏的风险。
3.2、auto_ptr 的缺陷
尽管 auto_ptr 的引入为自动化内存管理提供了一种解决方案，但它存在严重的缺陷，尤其是在所有权语义和复制行为上。auto_ptr 的最主要问题是它的 所有权转移语义 和 复制行为，这导致了许多意外的错误和内存问题。
3.2.1、所有权转移（Move Semantics）
auto_ptr 的核心问题在于它的复制语义。当一个 auto_ptr 对象被复制时，所有权会被转移到新的 auto_ptr，而原来的 auto_ptr 将不再持有该指针。这种所有权的隐式转移在实际使用中引发了很多问题。
示例代码：
std::auto_ptr<int> ptr1(new int(10));
std::auto_ptr<int> ptr2 = ptr1; // 所有权从 ptr1 转移到 ptr2
std::cout << (ptr1.get() == nullptr) << std::endl; // 输出: 1 (ptr1 为空)
std::cout << *ptr2 << std::endl; // 输出: 10
在上面的代码中，ptr2 复制了 ptr1，但实际上所有权发生了转移，导致 ptr1 不再拥有该资源。虽然这在某些场景下是有用的（比如在传递所有权时），但它违反了传统 C++ 中的复制语义。通常情况下，复制一个对象意味着两个对象共享相同的值或资源，但 auto_ptr 的行为不同，这导致了难以预料的错误。
3.2.2、不适用于标准容器
由于 auto_ptr 的复制行为，它无法存储在 C++ 的标准容器中（如 std::vector、std::list）。标准容器依赖于复制语义来管理其元素，而 auto_ptr 的所有权转移特性与此不兼容。
示例代码：
#include <memory>
#include <vector>
int main() {
std::vector<std::auto_ptr<int>> vec;
vec.push_back(std::auto_ptr<int>(new int(10))); // 错误！所有权转移破坏了容器的语义
}
在这个例子中，auto_ptr 无法在标准容器中使用，因为在 push_back 操作时会发生所有权转移，破坏了容器的元素管理机制。这也是 auto_ptr 最终被废弃的原因之一。
3.3、模拟实现 auto_ptr
namespace Lenyiin
{
// C++98 auto_ptr
// 1. 管理权转移，早起设计缺陷，一般公司都明令禁止使用它
// 缺陷：ap2 = ap1 场景下 ap1 就悬空了，访问就会报错，如果不熟悉它的特性就会被坑
template <class T>
class Auto_ptr
{
public:
// 默认构造
Auto_ptr(T* ptr = nullptr)
: _ptr(ptr)
{
}
// 拷贝构造
Auto_ptr(Auto_ptr<T>& ap)
: _ptr(ap._ptr)
{
std::cout << "拷贝构造, 管理权转移" << std::endl;
ap._ptr = nullptr;
}
// ap1 = ap2
Auto_ptr<T>& operator=(const Auto_ptr<T>& ap)
{
if (this != &ap)
{
if (_ptr)
{
std::cout << "赋值拷贝, delete: " << _ptr << std::endl;
delete _ptr;
}
_ptr = ap._ptr;
ap._ptr = nullptr;
}
return *this;
}
// 析构函数
~Auto_ptr()
{
if (_ptr)
{
std::cout << "析构 delete: " << _ptr << std::endl;
delete _ptr;
}
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
}
4、unique_ptr：独占所有权智能指针
由于 auto_ptr 的设计缺陷，C++11 标准引入了 unique_ptr，并逐渐取代了 auto_ptr。unique_ptr 解决了 auto_ptr 的所有权转移问题，并通过 移动语义 提供了更加安全和高效的内存管理方式。
std::unique_ptr具有独占所有权的特性。它意味着在任何时刻，只有一个 unique_ptr 能够管理某个资源，这确保了资源不会被多个对象意外共享。
4.1、unique_ptr 的优势
- 防止内存泄漏：
unique_ptr能在对象超出作用域时自动释放内存。 - 严格的独占所有权：
unique_ptr仅允许一个智能指针持有资源的所有权，任何复制行为都被禁用。只有通过 移动 才能转移所有权，这样的设计避免了auto_ptr的隐式所有权转移问题。 - 支持标准容器：由于
unique_ptr禁用了复制，标准容器可以安全地存储unique_ptr，因为标准容器依赖于移动语义，而不是复制语义。 - 性能优化：与
auto_ptr不同，unique_ptr支持更高效的内存管理，特别是在多线程环境中。 - 线程安全：由于
unique_ptr没有共享资源的概念，因此天然是线程安全的。
4.2、unique_ptr 的基本特性
unique_ptr 实现了独占所有权语义，任何时候只能有一个 unique_ptr 实例管理某个资源。它支持 移动语义，允许通过 移动构造 或 移动赋值 将资源的所有权从一个 unique_ptr 转移到另一个 unique_ptr。
4.2.1、unique_ptr 的构造与析构
unique_ptr 的构造函数允许传递一个原始指针来初始化它。当 unique_ptr 对象超出作用域时，它的析构函数会自动释放持有的资源（通过 delete 或 delete[] 调用）。
示例代码：
#include <iostream>
#include <memory>
int main()
{
{
std::unique_ptr<int> p1(new int(10)); // p1 独占一个 int 资源
std::cout << *p1 << std::endl; // 输出 10
}
// p1 超出作用域，资源被自动释放
return 0;
}
在这个示例中，unique_ptr 在超出作用域时自动调用其析构函数，释放动态分配的内存。
4.2.2、禁用复制语义
unique_ptr 禁用了复制构造函数和复制赋值运算符，因此无法通过复制操作共享所有权。这一设计确保了资源的独占所有权，避免了内存错误。
示例代码：
std::unique_ptr<int> p1(new int(42));
// std::unique_ptr<int> p2 = p1; // 错误：不能复制 unique_ptr
尝试复制 unique_ptr 会导致编译错误，避免了隐式的所有权转移问题
4.2.3、移动语义支持
尽管 unique_ptr 禁用了复制操作，但它支持 移动语义，允许通过移动构造或移动赋值将所有权从一个 unique_ptr 转移到另一个。
示例代码：
#include <iostream>
#include <memory>
int main()
{
std::unique_ptr<int> p1(new int(10));
std::unique_ptr<int> p2 = std::move(p1); // 所有权从 p1 转移到 p2
if (p1 == nullptr)
{
std::cout << "p1 为空" << std::endl; // p1 不再拥有资源
}
std::cout << *p2 << std::endl; // 输出 10
return 0;
}
在这个例子中，std::move(p1) 将 p1 中的资源所有权转移给 p2，之后 p1 变为空指针，且不再拥有该资源。
#include <memory>
#include <vector>
int main()
{
{
std::vector<std::unique_ptr<int>> vec;
vec.push_back(std::make_unique<int>(10)); // 安全！使用移动语义
}
// 超出作用域，资源被自动释放
}
在这个例子中，unique_ptr 可以安全地存储在 std::vector 中，并且通过移动语义来传递所有权，不会导致 auto_ptr 的那种隐式所有权转移问题。
4.2.4、自定义删除器
在某些特殊场景下，资源的释放方式可能需要自定义。unique_ptr 允许通过自定义删除器来管理资源的释放。自定义删除器可以是函数指针或函数对象。
struct Deleter {
void operator()(int* p) const
{
std::cout << "Deleting int pointer: " << *p << std::endl;
delete p;
}
};
int main() {
std::unique_ptr<int, Deleter> ptr(new int(100)); // 使用自定义删除器
}
自定义删除器的作用是在 unique_ptr 释放资源时调用特定的逻辑，适用于需要特殊清理操作的资源管理场景。
4.2.5、数组形式的 unique_ptr
除了管理单一对象，unique_ptr 还可以用于管理动态分配的数组。在这种情况下，需要在声明 unique_ptr 时使用数组版本的 unique_ptr，并且删除器会自动调用 delete[]。
std::unique_ptr<int[]> arr = std::make_unique<int[]>(10); // 动态分配一个数组
arr[0] = 1;
arr[1] = 2;
std::cout << arr[0] << ", " << arr[1] << std::endl;
在数组形式的 unique_ptr 中，访问数组元素的方式与常规指针相同，但内存管理是自动化的。
4.2.6、空指针安全
与原始指针不同，unique_ptr 是空指针安全的。即使 unique_ptr 不指向任何对象，它仍然是安全的，不会导致崩溃或未定义行为。
std::unique_ptr<int> ptr; // 空指针
if (!ptr) {
std::cout << "Pointer is null." << std::endl;
}
这使得 unique_ptr 的使用更加健壮，减少了空指针引发的程序崩溃的风险。
4.3、unique_ptr 的使用场景
由于其独占所有权和自动管理资源的特性，unique_ptr 适用于不需要共享资源的场景。例如，某个类内部的资源管理可以通过 unique_ptr 来实现，以确保对象的生命周期结束时，资源被正确释放。unique_ptr 适用于以下场景：
4.3.1、动态内存管理
当需要管理动态分配的内存并确保其自动释放时，unique_ptr 是非常合适的选择。例如在函数内部分配的临时对象，需要在函数结束时释放，可以使用 unique_ptr 来确保正确管理内存。
4.3.2、管理资源句柄
除了管理动态内存外，unique_ptr 也可以用于管理其他需要手动释放的资源，如文件句柄、网络连接、锁等。通过自定义删除器(deleter)，可以灵活地释放不同类型的资源。
示例代码：
#include <iostream>
#include <memory>
#include <cstdio>
struct FileDeleter {
void operator()(FILE* file) const
{
if (file)
{
std::fclose(file);
std::cout << "文件已关闭" << std::endl;
}
}
};
int main() {
std::unique_ptr<FILE, FileDeleter> file(std::fopen("example.txt", "r"));
// 当 file 超出作用域时，FileDeleter 会自动关闭文件
return 0;
}
在这个例子中，自定义的 FileDeleter 确保在 unique_ptr 超出作用域时，自动调用 fclose 关闭文件。
4.3.3、用于标准容器中
由于 unique_ptr 支持移动语义，因此它可以安全地存储在标准容器（如 std::vector）中。相比于 auto_ptr，unique_ptr 不会在存储过程中发生所有权隐式转移，确保了容器的正确性。
示例代码：
#include <iostream>
#include <memory>
#include <vector>
int main() {
std::vector<std::unique_ptr<int>> vec;
vec.push_back(std::make_unique<int>(10)); // 安全地存储 unique_ptr
for (const auto& elem : vec) {
std::cout << *elem << std::endl; // 输出 10
}
return 0;
}
通过 std::make_unique 创建 unique_ptr，并将其存储在容器中，既能安全管理内存，又能避免复杂的所有权问题。
4.3.4、内存池与 unique_ptr 的结合
在高性能需求的场景中，内存池技术可以与 unique_ptr 结合使用，以减少频繁的内存分配与释放带来的开销。通过自定义分配器，我们可以将 unique_ptr 的内存管理交给内存池，从而提高性能。
4.3.5、函数返回值
当一个函数返回动态分配的对象时，使用 unique_ptr 可以避免手动管理资源，并明确表示返回值的所有权转移。
std::unique_ptr<int> createInt(int value)
{
return std::make_unique<int>(value); // 返回 unique_ptr，自动管理内存
}
这种方式比返回原始指针要更加安全，因为调用者不需要显式管理资源释放。
4.4、unique_ptr 的基本实现
为了更好地理解 unique_ptr 的工作原理，我们可以分析其内部实现。unique_ptr 依赖于模板特性，并使用了移动语义来确保其独占所有权。
unique_ptr 是一个模板类，它封装了一个指针，并在析构时自动调用删除器来释放该指针所指向的资源。下面是一个简化的 unique_ptr 实现：
namespace Lenyiin
{
template <class T, class Deleter = std::default_delete<T>>
class Unique_ptr {
private:
T* ptr; // 原始指针
Deleter deleter; // 自定义删除器
public:
// 构造函数
explicit Unique_ptr(T* p = nullptr)
: ptr(p)
{}
// 禁用拷贝构造函数和赋值操作符
Unique_ptr(const Unique_ptr&) = delete;
Unique_ptr& operator=(const Unique_ptr&) = delete;
// 支持移动构造函数和移动赋值
Unique_ptr(Unique_ptr&& other) noexcept
: ptr(other.ptr)
{
other.ptr = nullptr;
}
// 移动赋值运算符
Unique_ptr& operator=(Unique_ptr&& other) noexcept
{
if (this != &other) {
reset();
ptr = other.ptr;
other.ptr = nullptr;
}
return *this;
}
// 析构函数
~Unique_ptr()
{
deleter(ptr); // 调用删除器释放资源
}
// 重载 * 和 -> 操作符
T& operator*() const
{
return *ptr;
}
T* operator->() const
{
return ptr;
}
// 获取底层指针
T* get() const
{
return ptr;
}
// 释放所有权
T* release()
{
T* oldPtr = ptr;
ptr = nullptr;
return oldPtr;
}
// 重置指针
void reset(T* p = nullptr)
{
delete ptr;
ptr = p;
}
};
}
unique_ptr 的核心是原始指针 ptr 和删除器 deleter。它禁用了复制语义，通过移动语义来传递所有权。reset() 方法允许用户手动重置指针并释放旧资源，而 release() 方法则可以释放所有权，并让用户手动管理指针的生命周期。
unique_ptr 的移动语义通过移动构造函数和移动赋值操作来实现。当资源的所有权被转移时，原来的智能指针会变成空指针，而新的智能指针则接管资源。移动构造函数和移动赋值操作都会将原智能指针中的资源指针设为 nullptr，确保原智能指针不再持有资源。这样可以避免重复释放资源的风险。
5、shared_ptr：共享所有权智能指针
std::shared_ptr 是 C++11 引入的另一种智能指针，允许多个 shared_ptr 对象共享同一个资源。其内部通过引用计数来管理资源的生命周期，当引用计数归零时，资源将被自动释放。简化了动态内存的管理并显著降低了内存泄漏的风险。
本章将深入探讨 shared_ptr 的使用场景、实现原理、性能特点，以及常见的陷阱和最佳实践。
5.1、什么是 shared_ptr
shared_ptr 是 C++ 标准库中的一种智能指针，允许多个指针对象共同拥有动态分配的对象。它通过维护一个引用计数器来跟踪有多少个 shared_ptr 指向同一个对象。当最后一个 shared_ptr 离开作用域时，引用计数归零，自动删除指向的对象。这种机制确保了对象在不再被使用时得到正确销毁，避免了内存泄漏。
shared_ptr 的核心特性
- 引用计数：
shared_ptr使用引用计数器来记录有多少个指针拥有同一个对象。当引用计数变为零时，shared_ptr会自动销毁该对象。 - 共享所有权：与
unique_ptr的独占所有权不同，shared_ptr允许多个指针共享对同一对象的所有权。 - 线程安全：
shared_ptr的引用计数是线程安全的，确保在多线程环境下可以安全地共享同一对象。
5.2、shared_ptr 的创建与使用
要创建一个 shared_ptr，我们可以直接使用构造函数，或者更推荐使用 std::make_shared 函数。这种方式不仅更加简洁，还能提升性能，因为它减少了内存分配次数。
5.2.1、创建 shared_ptr
#include <memory>
#include <iostream>
int main()
{
// 使用 make_shared 创建
std::shared_ptr<int> sp1 = std::make_shared<int>(10);
std::cout << "Shared pointer value: " << *sp1 << std::endl;
return 0;
}
在上面的例子中，std::make_shared 函数为我们创建了一个管理动态内存的 shared_ptr。它的内部机制可以更高效地分配内存，因为它将对象本身和引用计数器一起分配，而不是分开分配。
5.2.2、引用计数的示例
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp1 = std::make_shared<int>(10); // 引用计数为 1
{
std::shared_ptr<int> sp2 = sp1; // 引用计数为 2
std::cout << "Reference count inside block: " << sp1.use_count() << std::endl;
} // 离开作用域，sp2 销毁，引用计数变为 1
std::cout << "Reference count outside block: " << sp1.use_count() << std::endl;
return 0;
}
在这个例子中，当 sp2 复制了 sp1 后，引用计数从 1 变为 2。当 sp2 离开作用域时，引用计数会自动减少回 1。shared_ptr 通过 use_count() 函数可以查询当前的引用计数。
5.3、shared_ptr 的实现原理
在本节中，我们将深入探讨如何手动实现一个简化版的 shared_ptr。通过这个实现，我们可以更好地理解 shared_ptr 的内部机制和运作原理。请注意，下面的实现只是一个简化版本，真实的标准库实现可能包含更多的细节和优化。
5.3.1、shared_ptr 的内部结构
一个典型的控制块可能包含以下成员：
- 对象指针：指向动态分配的对象。
- 引用计数器：跟踪
shared_ptr的数量。 - 互斥锁：多线程高并发时保证线程安全
控制块的设计使得 shared_ptr 可以灵活地管理资源，不论是简单的对象还是自定义的资源（如文件句柄、网络连接）。
5.3.2、 shared_ptr 的生命周期
shared_ptr 的生命周期由引用计数决定。当引用计数器归零时，shared_ptr 会自动调用对象的析构函数并释放所管理的内存资源。以下是 shared_ptr 生命周期的几个重要阶段：
- 创建：当
shared_ptr创建时，控制块中的引用计数初始化为 1。 - 复制：当
shared_ptr被复制时，引用计数增加。 - 销毁：当
shared_ptr被销毁时，引用计数减少。当引用计数为 0 时，控制块会调用对象的析构函数。
5.3.3、shared_ptr 的实现
shared_ptr 的实现包括构造函数、析构函数、拷贝构造函数、赋值操作符等。下面是简化版的 shared_ptr 实现：
namespace Lenyiin
{
// C++11 Shared_Ptr
// 引用计数，可以拷贝
// 缺陷：循环引用
template <class T>
class Shared_ptr
{
public:
// 普通构造
Shared_ptr(T *ptr = nullptr)
: _ptr(ptr), _pcount(new int(1)), _pmtx(new std::mutex)
{}
// 拷贝构造
Shared_ptr(const Shared_ptr<T>& sp)
: _ptr(sp._ptr), _pcount(sp._pcount), _pmtx(sp._pmtx)
{
add_ref_count();
}
// 赋值操作
// sp1 = sp2
Shared_ptr<T>& operator=(const Shared_ptr<T>& sp)
{
if (this != &sp)
{
// 减减引用计数，如果我是最后一个管理资源的对象，则释放资源
release();
// 我开始和你一起管理资源
_ptr = sp._ptr;
_pcount = sp._pcount;
_pmtx = sp._pmtx;
add_ref_count();
}
return *this;
}
void add_ref_count()
{
_pmtx->lock();
++(*_pcount);
_pmtx->unlock();
}
void release()
{
bool flag = false;
_pmtx->lock();
if (--(*_pcount) == 0)
{
if (_ptr)
{
std::cout << "delete: " << _ptr << std::endl;
delete _ptr;
_ptr = nullptr;
}
delete _pcount;
_pcount = nullptr;
flag = true;
}
_pmtx->unlock();
if (flag == true)
{
delete _pmtx;
_pmtx = nullptr;
}
}
// 析构函数
~Shared_ptr()
{
release();
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
int use_count()
{
return *_pcount;
}
T* get_ptr() const
{
return _ptr;
}
private:
T* _ptr;
// 记录有多少个对象一起共享管理资源, 最后一个析构释放资源
int* _pcount;
//
std::mutex* _pmtx;
};
}
以上代码实现了一个简化版的 shared_ptr，包括基本的引用计数管理、控制块和指针管理。这个实现演示了 shared_ptr 的核心概念和工作原理。实际的标准库实现可能会有更多的细节和优化，但本实现提供了一个理解 shared_ptr 内部机制的良好基础。
5.3.4、shared_ptr 的功能测试
为了验证我们的 shared_ptr 实现的正确性，我们可以编写一些测试代码来检查基本的功能，包括构造、拷贝、赋值和析构。
#include <cassert>
int main() {
// 测试构造函数
shared_ptr<int> sp1(new int(10));
assert(*sp1 == 10);
// 测试指针计数
std::cout << "sp1: " << sp1.use_count() << std::endl;
// 测试拷贝构造函数
shared_ptr<int> sp2(sp1);
assert(*sp2 == 10);
assert(*sp1 == 10);
std::cout << "sp2: " << sp2.use_count() << std::endl;
// 测试赋值操作符
shared_ptr<int> sp3;
sp3 = sp1;
assert(*sp3 == 10);
assert(*sp1 == 10);
std::cout << "sp3: " << sp3.use_count() << std::endl;
return 0;
}
5.4、shared_ptr 的最佳实践
为了充分发挥 shared_ptr 的优势，同时避免其潜在的陷阱，以下是一些最佳实践：
5.4.1、复杂对象的生命周期管理
shared_ptr 的典型应用场景是在复杂的系统中，多个对象需要共享同一个资源时。例如，在 GUI 应用程序中，多个控件可能共享同一个数据模型。当某个控件被销毁时，数据模型应该继续存在，直到最后一个控件不再需要它。这种场景中，shared_ptr 可以确保数据模型的生命周期正确管理。
5.4.2、与 weak_ptr 结合使用
在某些场景下，可能需要打破对象之间的循环引用。例如，两个对象 A 和 B 相互拥有对方的指针，如果都使用 shared_ptr，将导致引用计数永远不会归零，资源得不到释放。为了解决这种问题，C++ 提供了 weak_ptr（弱指针）来管理弱引用。weak_ptr 不会增加引用计数，可以用来打破循环依赖。
#include <memory>
#include <iostream>
struct B; // 前向声明
struct A {
std::shared_ptr<B> bptr;
~A() { std::cout << "A destroyed" << std::endl; }
};
struct B {
std::weak_ptr<A> aptr; // 使用 weak_ptr 打破循环依赖
~B() { std::cout << "B destroyed" << std::endl; }
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
a->bptr = b;
b->aptr = a; // 若使用 shared_ptr，会造成循环依赖
return 0;
}
在这个例子中，A 和 B 相互引用。通过将 B 的指针声明为 weak_ptr，打破了循环依赖，从而允许正确释放对象。
5.4.3、使用 std::make_shared 创建 shared_ptr
std::make_shared 是创建 shared_ptr 的推荐方式。它不仅能减少内存分配次数，还能提高性能和安全性。避免直接使用 new 创建 shared_ptr。
std::shared_ptr<int> sp = std::make_shared<int>(42); // 推荐方式
5.4.4、避免不必要的复制
尽量避免在函数参数和返回值中使用 shared_ptr 的复制操作。如果需要传递或返回 shared_ptr，考虑使用 const std::shared_ptr<T>& 或 std::shared_ptr<T>&&（右值引用）。
void process(const std::shared_ptr<int>& sp)
{
// 只读访问，避免不必要的复制
}
5.4.5、理解 shared_ptr 的生命周期
要清楚 shared_ptr 的生命周期规则。在 shared_ptr 的生命周期内，不应访问已被销毁的对象。对 shared_ptr 的所有权和生命周期有清晰的理解，可以避免常见的错误和资源泄漏。
5.4.6、weak_ptr 的锁定机制
weak_ptr 的一个重要特性是它不会直接访问资源，而是需要通过 lock() 方法将自身转化为 shared_ptr，以安全地访问资源。这样可以确保资源在使用时仍然有效，而当资源已经被释放时，lock() 返回的 shared_ptr 将为空。
std::shared_ptr<int> sptr = std::make_shared<int>(42);
std::weak_ptr<int> wptr = sptr;
if (std::shared_ptr<int> locked = wptr.lock()) {
std::cout << "Resource is still alive: " << *locked << std::endl;
} else {
std::cout << "Resource has been released" << std::endl;
}
上面的代码通过 lock() 方法来获取资源，并且检查资源是否已经被释放。如果资源已经被释放，locked 将为 nullptr，从而避免了访问已释放内存的风险。
5、智能指针总结
在 C++ 中，智能指针提供了一个管理动态内存的安全机制，避免了内存泄漏和悬挂指针问题。C++ 标准库中提供了多种智能指针，其中最常用的包括 auto_ptr、unique_ptr 和 shared_ptr。每种智能指针都有其独特的特性和适用场景。以下是对这三种智能指针的总结。
5.1、auto_ptr
auto_ptr 是 C++98 标准引入的智能指针，用于自动管理动态分配的内存。它实现了所有权转移，但由于其不符合现代 C++ 的设计理念和安全要求，在 C++11 中被标记为废弃，并在 C++17 中被移除。
特点：
- 所有权转移：
auto_ptr支持通过拷贝构造和赋值操作符转移所有权。原智能指针在转移后变为nullptr。 - 不安全：由于所有权转移的特性，
auto_ptr可能导致意外的资源管理错误和潜在的悬挂指针问题。 - 废弃：
auto_ptr已被C++11标准标记为废弃，建议使用unique_ptr或shared_ptr替代。
5.2、unique_ptr
unique_ptr 是 C++11 引入的智能指针，提供了独占所有权的管理机制。它保证了在任何时刻只有一个 unique_ptr 拥有对象的所有权，从而避免了资源泄漏。
特点：
- 独占所有权：
unique_ptr只允许一个unique_ptr拥有对象的所有权，不能被拷贝，只能通过move操作转移所有权。 - 资源释放：当
unique_ptr被销毁时，它会自动释放所管理的对象。 - 高效：
unique_ptr不需要额外的内存来存储引用计数，性能开销较小。
5.3、shared_ptr
shared_ptr 是 C++11 引入的智能指针，允许多个 shared_ptr 实例共享同一个对象的所有权。它使用引用计数机制来管理对象的生命周期，确保在最后一个 shared_ptr 被销毁时才释放对象。
特点：
- 共享所有权：多个
shared_ptr可以共享同一个对象的所有权，通过引用计数来跟踪对象的生命周期。 - 线程安全：引用计数的更新是线程安全的。
- 性能开销：需要额外的内存来存储引用计数，性能开销较
unique_ptr大。 - 循环引用：需要小心处理循环引用问题，可以使用
weak_ptr来打破循环引用。
5.4、总结
auto_ptr：- 优点：简单易用，早期
C++的智能指针实现。 - 缺点：不安全，所有权转移可能导致悬挂指针。
- 状态：已废弃，不建议使用。
- 优点：简单易用，早期
unique_ptr：- 优点：独占所有权，资源管理简单高效，无需引用计数。
- 缺点：不能被拷贝，只能通过
move转移所有权。 - 适用场景：需要独占所有权的场景，例如局部对象和工厂模式。
shared_ptr：- 优点：支持共享所有权，通过引用计数管理对象生命周期，线程安全。
- 缺点：性能开销较大，可能存在循环引用问题。
- 适用场景：需要多个对象共享同一个资源的场景，例如观察者模式和缓存系统。
智能指针是 C++ 内存管理中的重要工具，它们通过 RAII 模式和引用计数机制极大地简化了内存的分配和释放。在现代 C++ 中，unique_ptr、shared_ptr 和 weak_ptr 分别解决了独占所有权、共享所有权和循环引用等问题，成为了 C++ 编程中不可或缺的部分。
了解这些智能指针的特性和使用场景，可以帮助开发者选择合适的智能指针，提高代码的安全性和可维护性。在实际开发中，选择合适的智能指针来管理资源，可以有效地避免内存泄漏和资源管理错误。
通过本文的详细讲解和代码示例，我们不仅介绍了智能指针的基础知识，还探讨了其内部实现和自定义实现。希望读者在阅读本文后，能够对智能指针有一个更加全面和深入的理解，并能够在实际开发中灵活运用智能指针管理内存。
希望这篇博客对您有所帮助，也欢迎您在此基础上进行更多的探索和改进。如果您有任何问题或建议，欢迎在评论区留言，我们可以共同探讨和学习。更多知识分享可以访问我的个人博客网站 ： https://blog.lenyiin.com/ 。
![[基于 Vue CLI 5 + Vue 3 + Ant Design Vue 4 搭建项目] 07 如何修改 npm run serve 的启动端口号](https://i-blog.csdnimg.cn/direct/17aff2bd1b434dbe8f5514b5abc76b8d.png#pic_center)
![【Python】由二维列表初始化导致修改元素时会修改相同位置元素的引用问题f = [[0] * len(matrix[0])] * len(matrix)](https://i-blog.csdnimg.cn/direct/c81cda599ce84d8db859f9a55c35beb6.png)
