1. 引言
1.1 智能指针的重要性
在C++编程中，内存管理一直是一个不可或缺的话题。传统的C++程序员依赖new和delete（新建和删除）来手动管理内存，但这种方式容易导致内存泄漏或是双重释放等问题。这就是智能指针（Smart Pointers）登场的原因。
智能指针不仅仅是一个指针，它是一个对象，拥有生命周期（Lifetime）。当智能指针的生命周期结束时，它会自动释放所拥有的资源。这种自动管理机制极大地减少了程序员的负担，也降低了出错的可能性。
“The best code is no code at all.” - Jeff Atwood
这句话在这里非常合适。越少的代码用于管理内存，越少的地方会出错。智能指针就是这样一种工具，让你能更专注于业务逻辑而非内存管理。
1.2 自定义删除器的需求场景
虽然标准库提供的智能指针非常强大，但有时候它们还是不能满足所有需求。例如，当你需要管理的不仅仅是内存，可能是一个文件句柄（File Handle）或者数据库连接（Database Connection）时，标准的删除器就显得力不从心。
1.2.1 非堆内存资源
在许多情况下，你可能需要管理的资源并不是通过new或malloc分配的堆内存。这些资源可能是操作系统级别的，比如文件句柄或线程。这时，你需要一个更加灵活的删除器。
1.2.2 第三方库
当你的代码需要与第三方库集成时，这些库可能有自己的资源管理机制。在这种情况下，使用自定义删除器可以让你的智能指针与第三方库的资源管理无缝对接。
“We cannot solve our problems with the same thinking we used when we created them.” - Albert Einstein
这句话在这里意味着，当面对新的问题时，我们需要新的解决方案。自定义删除器就是这样一种解决方案，它让智能指针更加灵活，能适应更多的场景。
代码示例
让我们通过一个简单的代码示例来看看如何使用std::unique_ptr（唯一指针）和自定义删除器。
#include <iostream> #include <memory> // 自定义删除器 void customDeleter(int* ptr) { std::cout << "Custom deleter called." << std::endl; delete ptr; } int main() { std::unique_ptr<int, decltype(&customDeleter)> smartPtr(new int(42), customDeleter); // ... do something ... return 0; }
在这个例子中，我们定义了一个自定义删除器customDeleter，并将其传递给std::unique_ptr。当smartPtr的生命周期结束时，customDeleter会被自动调用，从而释放资源。
| 方法 | 是否自动管理资源 | 是否支持自定义删除器 |
| new/delete | 否 | 否 |
| std::unique_ptr | 是 | 是 |
| std::shared_ptr | 是 | 是 |
通过这个表格，你可以清晰地看到使用智能指针和自定义删除器的优势。
2. C++标准库中的智能指针
2.1 std::unique_ptr
std::unique_ptr（独占指针）是C++11标准引入的一种智能指针。它的主要特点是独占所指向的对象，即同一时间只能有一个std::unique_ptr指向该对象。
2.1.1 基本用法
#include <memory> int main() { std::unique_ptr<int> p1(new int(42)); // std::unique_ptr<int> p2 = p1; // 编译错误，不能复制 std::unique_ptr<int> p3 = std::move(p1); // 现在p3独占资源，p1变为空 }
2.1.2 底层实现
std::unique_ptr底层通常使用模板和删除器（deleter）来实现。当std::unique_ptr的实例销毁时，删除器会被调用以释放资源。
2.1.3 方法对比
| 方法 | 说明 |
reset() |
释放资源并将指针置为空 |
release() |
释放资源的所有权但不删除，返回原始指针 |
2.2 std::shared_ptr
std::shared_ptr（共享指针）与std::unique_ptr不同，它允许多个std::shared_ptr实例共享同一个对象。
2.2.1 基本用法
#include <memory> int main() { std::shared_ptr<int> p1(new int(42)); std::shared_ptr<int> p2 = p1; // p1和p2共享资源 }
2.2.2 底层实现
std::shared_ptr底层使用引用计数（reference counting）来跟踪有多少个shared_ptr实例共享同一个资源。
2.2.3 方法对比
| 方法 | 说明 |
use_count() |
返回共享该资源的shared_ptr数量 |
reset() |
释放资源并将指针置为空 |
2.3 std::weak_ptr
std::weak_ptr（弱指针）是一种特殊的智能指针，它不会增加引用计数。
2.3.1 基本用法
#include <memory> int main() { std::shared_ptr<int> p1(new int(42)); std::weak_ptr<int> wp1 = p1; // wp1不增加引用计数 }
2.3.2 底层实现
std::weak_ptr底层与std::shared_ptr共享相同的引用计数机制，但不会增加计数。
2.3.3 方法对比
| 方法 | 说明 |
lock() |
返回一个shared_ptr，增加引用计数 |
expired() |
检查资源是否还存在 |
人们通常喜欢拥有独一无二的东西，这与std::unique_ptr的独占性质相似。而std::shared_ptr则像是社交网络中的热门话题，多人共享，但也需要管理。std::weak_ptr则像是那些观察者，不参与但了解情况。
3. 什么是自定义删除器
3.1 删除器的基本概念
在C++中，智能指针（Smart Pointers）如std::unique_ptr和std::shared_ptr默认使用delete或delete[]来释放内存。但有时，这种默认行为可能不适用于所有场景。这就是自定义删除器（Custom Deleters）进入游戏的地方。
3.1.1 默认删除器
默认情况下，std::unique_ptr和std::shared_ptr使用以下方式进行删除：
delete ptr; delete[] arr_ptr;
这些删除器在大多数情况下都很有用，但有时我们需要更多的灵活性。
3.1.2 自定义删除器的需求
想象一下，你正在与一个老旧的C库交互，该库要求使用特定的函数来释放内存，例如custom_free(ptr)。在这种情况下，使用默认的delete将不适用。
3.2 为什么需要自定义删除器
3.2.1 管理非堆内存资源
除了内存，智能指针还可以用于管理其他类型的资源，例如文件句柄、互斥锁或数据库连接。这些资源可能需要特定的释放机制。
3.2.2 代码可读性和维护性
使用自定义删除器可以提高代码的可读性和维护性。它使资源的获取和释放逻辑紧密地绑定在一起，从而减少了出错的机会。
“代码是写给人看的，顺便能被机器执行。” —— Donald Knuth
这句话强调了代码可读性的重要性。当你明确地指定如何释放资源，你实际上是在与未来的你或其他开发者进行沟通。
3.2.3 异常安全
自定义删除器有助于实现异常安全（Exception Safety）。当构造函数可能抛出异常时，使用智能指针和自定义删除器可以确保资源被正确释放。
“人们总是高估自己对复杂系统行为的理解。” —— Daniel Kahneman
这句心理学名言提醒我们，即使是最简单的代码也可能隐藏复杂性和潜在的错误。自定义删除器提供了一种机制，可以在复杂的错误处理逻辑中保持清晰和简洁。
3.3 自定义删除器的使用示例
让我们通过一个简单的例子来看看如何使用自定义删除器。
#include <iostream> #include <memory> void custom_deleter(int* p) { std::cout << "Custom deleter called\n"; delete p; } int main() { std::unique_ptr<int, decltype(&custom_deleter)> p(new int, custom_deleter); *p = 42; return 0; }
在这个例子中，我们定义了一个名为custom_deleter的自定义删除器，并将其传递给std::unique_ptr。
3.3.1 方法对比
| 方法 | 适用场景 | 优点 | 缺点 |
| 默认删除器 | 堆内存 | 简单、高效 | 不够灵活 |
| 函数对象（Functor） | 需要状态的复杂资源管理 | 灵活、可维护 | 可能增加内存开销 |
| Lambda表达式 | 简单的自定义逻辑 | 简洁、现代 | 不能携带状态 |
std::function |
需要多态删除器 | 高度灵活 | 性能和内存开销 |
通过这种方式，我们可以更深入地理解自定义删除器的不同用法和适用场景，从而做出更明智的决策。
4. 自定义删除器的设计
4.1 函数对象（Functor）作为删除器
在C++中，函数对象（Functor）是一种非常灵活的机制，它允许我们将行为（behavior）封装为对象。这在设计自定义删除器时非常有用。
4.1.1 什么是函数对象
函数对象是重载了operator()的类或结构体。这意味着你可以像调用函数一样使用这些对象。
struct MyDeleter { void operator()(int* ptr) { delete ptr; } };
4.1.2 如何使用函数对象作为自定义删除器
使用std::unique_ptr（唯一指针）或std::shared_ptr（共享指针）时，你可以将函数对象作为第二个模板参数传递。
std::unique_ptr<int, MyDeleter> p(new int, MyDeleter());
这种方式的优点是类型安全和高效。因为删除器是类型的一部分，编译器可以在编译时进行优化。
“Premature optimization is the root of all evil.” —— Donald Knuth
这句话提醒我们，优化应该在确实需要的时候进行，但在设计自定义删除器时，类型安全和编译时优化是我们所追求的。
4.2 Lambda表达式作为删除器
Lambda表达式（Lambda Expression）在C++11后成为了语言的一部分，它提供了一种更简洁、更直观的方式来定义简单的函数对象。
4.2.1 Lambda表达式的基础
Lambda表达式基本上是一个匿名函数。你可以这样使用它：
auto deleter = [](int* ptr) { delete ptr; };
4.2.2 如何使用Lambda表达式作为自定义删除器
与函数对象类似，Lambda表达式可以直接作为std::unique_ptr或std::shared_ptr的删除器。
std::unique_ptr<int, decltype(deleter)> p(new int, deleter);
这种方式的优点是简洁和直观。你不需要定义一个完整的结构体或类，只需要一个简单的Lambda表达式。
“Simplicity is the ultimate sophistication.” —— Leonardo da Vinci
这句话强调了简单性的重要性。在编程中，简单通常意味着更少的错误和更容易的维护。
4.3 与std::function结合
std::function（标准函数）是一种通用、多态的函数封装。它的实例可以对任何可以调用的目标实体进行存储、复制和调用操作，这包括普通函数、Lambda表达式、函数对象等。
4.3.1 std::function的基础
std::function是定义在头文件中的一个模板类。
std::function<void(int*)> func = [](int* ptr){ delete ptr; };
4.3.2 使用std::function作为自定义删除器
std::unique_ptr<int, std::function<void(int*)>> p(new int, func);
这种方式的优点是灵活性极高，你可以在运行时改变删除器。
| 方法 | 类型安全 | 编译时优化 | 灵活性 | 简洁性 |
| 函数对象（Functor） | ✅ | ✅ | ❌ | ❌ |
| Lambda表达式 | ✅ | ✅ | ❌ | ✅ |
std::function |
✅ | ❌ | ✅ | ❌ |
通过这个表格，你可以更清晰地看到每种方法的优缺点，从而做出更合适的选择。
5. 自定义删除器的应用场景
5.1 管理非堆内存资源
在C++中，智能指针（Smart Pointers）通常用于管理堆内存。但有时，我们需要管理其他类型的资源，比如文件句柄、数据库连接等。这时，自定义删除器（Custom Deleters）就派上了用场。
5.1.1 文件句柄
考虑一个场景，你需要打开一个文件并在操作完成后关闭它。通常，你可能会使用std::fstream，但假设你需要使用C风格的FILE*。
std::unique_ptr<FILE, decltype(&fclose)> smartFile(fopen("file.txt", "r"), fclose);
在这里，fclose作为自定义删除器，确保文件在smartFile离开作用域时被关闭。
5.1.2 数据库连接
如果你正在使用某种数据库库，通常这些库会提供自己的资源释放函数。你可以用自定义删除器来确保资源被正确释放。
std::unique_ptr<db_connection, decltype(&db_close)> conn(db_open("localhost"), db_close);
5.2 处理特殊的内存布局
有时，你可能需要管理一块内存，这块内存可能是通过某种特殊方式分配的，比如使用了aligned_alloc。
5.2.1 对齐内存
对于需要对齐的内存，你可以这样做：
std::unique_ptr<int[], decltype(&std::free)> p(static_cast<int*>(std::aligned_alloc(16, sizeof(int)*1024)), std::free);
这里，std::free作为自定义删除器，确保内存在智能指针销毁时被释放。
5.3 与第三方库集成
当你使用第三方库时，通常这些库会有自己的资源管理机制。但这些机制可能不是RAII（Resource Acquisition Is Initialization，资源获取即初始化）风格的，这时你可以用自定义删除器来“封装”这些资源。
5.3.1 封装OpenGL资源
假设你正在使用OpenGL，并且你需要管理一个纹理。OpenGL提供了glDeleteTextures来释放纹理，你可以这样封装：
std::unique_ptr<GLuint, decltype(&glDeleteTextures)> texture(new GLuint, glDeleteTextures);
这样，当texture离开作用域时，glDeleteTextures会被调用，纹理资源会被正确释放。
编程知识与心理学角度
人们通常更容易理解和记住那些与他们日常生活有关的事物。自定义删除器就像是你家里的垃圾分类系统。你不仅需要知道什么是可回收的（堆内存），还需要知道如何处理特殊垃圾（非堆内存资源）。这样，当你面对复杂的编程问题时，你就能更自然地想到使用自定义删除器。
代码示例与技术对比
| 方法 | 适用场景 | 删除器类型 | 优点 | 缺点 |
| 默认删除器 | 堆内存 | 函数指针 | 简单，无需额外代码 | 不够灵活 |
| 函数对象（Functor） | 非堆内存资源 | 类对象 | 灵活，可携带状态 | 可能增加内存开销 |
| Lambda表达式 | 简单资源管理 | 匿名函数 | 简洁，易于理解 | 不能携带状态 |
6. 性能考量
6.1 删除器的性能影响
在C++中，性能通常是一个关键考虑因素，特别是在系统编程和高性能计算中。智能指针（Smart Pointers）自然也不例外。当我们谈到自定义删除器（Custom Deleters）时，一个立即出现的问题是：这会影响性能吗？
6.1.1 函数对象与Lambda表达式
函数对象（Functors）和Lambda表达式（Lambda Expressions）通常是编译时（Compile-time）解析的，这意味着它们几乎没有运行时（Run-time）开销。然而，如果你的删除器做了一些复杂的操作，那么这些操作自然会有性能影响。
| 方法 | 编译时开销 | 运行时开销 | 灵活性 |
| 函数对象（Functor） | 低 | 低 | 中 |
| Lambda表达式 | 低 | 低 | 高 |
std::function |
中 | 中 | 高 |
6.1.2 std::function的影响
使用std::function作为删除器可能会引入一些额外的运行时开销，因为它需要在堆（Heap）上分配内存来存储可调用对象。这是一个权衡灵活性和性能的经典例子。
6.2 如何优化
“早优化是万恶之源”（“Premature optimization is the root of all evil”）这句话出自Donald Knuth的名著《计算机程序设计艺术》（“The Art of Computer Programming”）。在考虑优化之前，首先要明确是否真的需要。
6.2.1 避免不必要的复杂性
人们通常会过度设计删除器，导致不必要的复杂性和性能开销。这与人们天生喜欢复杂和多样性的心理特质有关。简单通常是最好的策略。
6.2.2 编译时解析
尽量使用编译时解析的方法，如函数对象或Lambda表达式，以减少运行时开销。
// 使用Lambda表达式作为自定义删除器 std::unique_ptr<MyClass, decltype([](MyClass* p){ delete p; })> p(new MyClass, [](MyClass* p){ delete p; });
6.2.3 利用现有库
有时，标准库或第三方库已经提供了高效的删除器实现。在不重新发明轮子的前提下，利用这些现有实现通常是明智的。
7. 实例分析
7.1 使用自定义删除器管理文件句柄
在C++编程中，文件操作是一个常见的任务。通常，我们会使用C++标准库中的fstream进行文件操作。但有时，特别是在与C语言库或操作系统API交互时，我们可能需要使用原始的文件句柄。这时，智能指针（Smart Pointers）与自定义删除器（Custom Deleters）就能大显身手。
7.1.1 设计自定义删除器
假设我们使用C语言的FILE*作为文件句柄。在C++中，我们可以设计一个自定义删除器来确保文件句柄被正确关闭。这里，我们可以使用Lambda表达式（Lambda Expressions）作为自定义删除器。
auto fileDeleter = [](FILE* fp) { fclose(fp); };
这个Lambda表达式接受一个FILE*参数，并调用fclose来关闭文件。这样，当std::unique_ptr或std::shared_ptr销毁时，这个删除器会自动被调用。
7.1.2 应用自定义删除器
应用自定义删除器非常简单。你只需要在创建智能指针时将其作为第二个模板参数传入。
std::unique_ptr<FILE, decltype(fileDeleter)> smartFile(fp, fileDeleter);
这样，当smartFile离开作用域或被显式销毁时，fileDeleter会自动被调用，从而关闭文件。
方法对比
| 方法 | 优点 | 缺点 |
| Lambda表达式 | 简单，易于理解 | 无 |
| 函数对象 | 可复用，可带状态 | 较复杂 |
std::function |
可以存储任何可调用对象 | 性能开销 |
7.2 使用自定义删除器进行异常安全编程
异常安全（Exception Safety）是C++编程中一个容易被忽视但极其重要的方面。当代码抛出异常时，如果没有妥善管理资源，很容易导致资源泄露或未定义行为。
7.2.1 设计异常安全的自定义删除器
考虑一个数据库连接的例子。通常，数据库连接需要在使用后显式关闭。但如果在执行数据库操作期间发生异常，程序可能会跳过关闭数据库的代码。
这时，自定义删除器就能派上用场。我们可以设计一个删除器，它在销毁时会自动关闭数据库连接。
auto dbDeleter = [](Database* db) { db->close(); };
7.2.2 应用异常安全的自定义删除器
与文件句柄的例子类似，我们可以这样应用自定义删除器：
std::unique_ptr<Database, decltype(dbDeleter)> smartDB(db, dbDeleter);
这样，即使在异常发生时，smartDB的析构函数也会调用dbDeleter，确保数据库连接被正确关闭。
方法对比
| 方法 | 优点 | 缺点 |
| Lambda表达式 | 简单，易于理解 | 无 |
| 函数对象 | 可复用，可带状态 | 较复杂 |
std::function |
可以存储任何可调用对象 | 性能开销 |
在这两个实例中，我们看到自定义删除器不仅能帮助我们管理复杂的资源，还能增强代码的异常安全性。这正如著名心理学家阿布拉罕·马斯洛（Abraham Maslow）所说：“如果你只有一把锤子，你会把每个问题都当作钉子。”智能指针和自定义删除器为我们提供了更多的工具，使我们能更灵活、更安全地解决问题。
8. 注意事项与最佳实践
8.1 删除器的可移植性
在设计自定义删除器（Custom Deleters）时，一个容易被忽视但非常重要的方面是可移植性（Portability）。许多开发者在一个特定的系统或库上进行开发，容易忽视代码在其他环境下的行为。
8.1.1 平台依赖性
例如，如果你的删除器是为了释放Linux系统上的某种资源而设计的，那么在Windows或MacOS上可能就不适用。这种情况下，使用#ifdef预处理器指令来区分不同的平台是一种常见做法。
std::shared_ptr<Resource> res( acquireResource(), [](Resource* r) { #ifdef LINUX linuxRelease(r); #elif defined(WINDOWS) windowsRelease(r); #endif } );
8.1.2 库依赖性
另一个常见问题是库依赖性。如果你的删除器依赖于某个第三方库，那么这个库必须在所有目标平台上都可用。
8.2 删除器与多态
多态（Polymorphism）是OOP（面向对象编程，Object-Oriented Programming）中的一个核心概念。然而，在使用自定义删除器时，多态可能会带来一些问题。
8.2.1 动态类型与删除器
当你有一个指向基类（Base Class）的智能指针，并且这个智能指针实际上管理着一个派生类（Derived Class）的对象时，你需要确保删除器能正确地释放派生类的资源。
std::unique_ptr<Base> ptr = std::make_unique<Derived>();
在这种情况下，如果Base类的析构函数不是虚函数（Virtual Destructor），则删除器可能无法正确地释放Derived类的资源。
8.2.2 虚析构函数
为了解决这个问题，你应该总是为具有派生类的基类定义虚析构函数。
class Base { public: virtual ~Base() {} };
这样，删除器就能通过基类指针正确地调用派生类的析构函数，从而释放所有资源。
8.3 方法对比
| 方法 | 适用场景 | 优点 | 缺点 |
| 函数对象（Functor） | 通用 | 灵活，可复用 | 需要定义额外的类 |
| Lambda表达式 | 简单场景 | 简洁，易于理解 | 不易复用 |
std::function |
高度动态场景 | 高度灵活，可变更 | 性能开销 |
这个表格总结了不同类型的删除器在不同场景下的适用性，以及各自的优缺点。
结语
在我们的编程学习之旅中，理解是我们迈向更高层次的重要一步。然而，掌握新技能、新理念，始终需要时间和坚持。从心理学的角度看，学习往往伴随着不断的试错和调整，这就像是我们的大脑在逐渐优化其解决问题的“算法”。
这就是为什么当我们遇到错误，我们应该将其视为学习和进步的机会，而不仅仅是困扰。通过理解和解决这些问题，我们不仅可以修复当前的代码，更可以提升我们的编程能力，防止在未来的项目中犯相同的错误。
我鼓励大家积极参与进来，不断提升自己的编程技术。无论你是初学者还是有经验的开发者，我希望我的博客能对你的学习之路有所帮助。如果你觉得这篇文章有用，不妨点击收藏，或者留下你的评论分享你的见解和经验，也欢迎你对我博客的内容提出建议和问题。每一次的点赞、评论、分享和关注都是对我的最大支持，也是对我持续分享和创作的动力。
