自定义删除器使智能指针能管理文件句柄、网络连接等非内存资源，通过RAII确保资源安全释放，提升代码健壮性与通用性。
C++智能指针的自定义删除器，本质上就是为智能指针提供一个“如何释放”的特殊指令，让它在管理内存之外，还能妥善处理文件句柄、网络连接或其他需要特定清理流程的资源。这使得智能指针的应用范围大大扩展，从单纯的内存管理工具升级为通用的资源管理利器，让资源管理变得更加自动化、安全且富有弹性。
解决方案
在C++中，智能指针（主要是
std::unique_ptr
和
std::shared_ptr
）默认知道如何使用
delete
操作符来释放它们所管理的堆内存。但现实世界中，我们常常需要管理那些并非通过
new
分配，或者需要特定函数（如
fclose
、
CloseHandle
、
free
等）来释放的资源。这时候，自定义删除器就派上用场了。它允许我们告诉智能指针，当它不再需要管理某个资源时，应该调用哪个函数或执行哪段代码来完成清理工作。
我们通常有几种方式来定义这个“清理指令”：函数对象（Functor）、Lambda表达式或者普通的函数指针。
1. 使用
std::unique_ptr
自定义删除器
立即学习“C++免费学习笔记（深入）”；
std::unique_ptr
的自定义删除器类型是其模板参数的一部分，这意味着如果你使用了一个带有自定义删除器的
unique_ptr
，它的完整类型会包含这个删除器类型。
函数对象（Functor）作为删除器：当清理逻辑比较复杂，或者希望删除器能携带一些状态时，函数对象是个不错的选择。
#include #include #include // For FILE*// 定义一个文件关闭器，它是一个函数对象struct FileCloser { void operator()(FILE* fp) const { if (fp) { std::cout << "DEBUG: Closing file handle via FileCloser." << std::endl; fclose(fp); } }};void demo_unique_ptr_functor() { // unique_ptr的第二个模板参数需要指定删除器的类型 std::unique_ptr logFile(fopen("app.log", "w")); if (logFile) { fprintf(logFile.get(), "Application started.n"); // ... 更多操作 ... } std::cout << "INFO: logFile unique_ptr scope ending." << std::endl; // 当logFile超出作用域时，FileCloser::operator()会被调用}
Lambda表达式作为删除器：对于一次性、局部性的清理任务，Lambda表达式非常简洁高效，尤其当它需要捕获一些上下文变量时。
#include #include #include // For std::jthread example#include // For std::move// 假设我们有一个需要join的线程void demo_unique_ptr_lambda_thread() { auto thread_deleter = [](std::jthread* t) { if (t && t->joinable()) { std::cout << "DEBUG: Joining thread via lambda deleter." <join(); delete t; // 别忘了释放线程对象本身 } else if (t) { delete t; } }; // unique_ptr的第二个模板参数需要通过decltype获取lambda的类型 std::unique_ptr worker(new std::jthread([]{ std::cout << "Worker thread running..." << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::cout << "Worker thread finished." << std::endl; }), thread_deleter); std::cout << "INFO: Main thread waiting for worker." << std::endl; // worker超出作用域时，lambda会被调用，确保线程被join}
函数指针作为删除器：最简单直接的方式，适用于无状态的全局或静态清理函数。
#include #include #include // For free// 一个通用的free函数，适用于通过malloc分配的内存void free_deleter(void* ptr) { if (ptr) { std::cout << "DEBUG: Calling free() via function pointer deleter." << std::endl; free(ptr); }}void demo_unique_ptr_func_ptr() { // unique_ptr的第二个模板参数是函数指针类型 std::unique_ptr data( static_cast(malloc(sizeof(int))), &free_deleter); if (data) { *data = 42; std::cout << "Data allocated with malloc: " << *data << std::endl; } std::cout << "INFO: data unique_ptr scope ending." << std::endl; // data超出作用域时，free_deleter会被调用}
2. 使用
std::shared_ptr
自定义删除器
std::shared_ptr
处理自定义删除器的方式与
unique_ptr
略有不同。它的删除器类型不是其自身模板参数的一部分，而是作为构造函数的一个参数传递。这意味着所有
shared_ptr
实例都可以有不同的删除器，而它们的类型仍然是
std::shared_ptr
。这得益于
shared_ptr
内部的类型擦除机制。
#include #include #include #include // For std::ofstream// 假设我们有一个自定义的资源类，需要特定的关闭方法class NetworkConnection { std::string _host; int _port; bool _isOpen = false;public: NetworkConnection(const std::string& host, int port) : _host(host), _port(port) { std::cout << "NetworkConnection to " << _host << ":" << _port << " established." << std::endl; _isOpen = true; } void send(const std::string& data) { if (_isOpen) { std::cout << "Sending data to " << _host << ": " << data << std::endl; } } void close() { if (_isOpen) { std::cout << "NetworkConnection to " << _host << ":" << _port << " closed." << std::endl; _isOpen = false; } } // 析构函数，但我们希望通过自定义删除器来调用close() ~NetworkConnection() { std::cout << "NetworkConnection destructor called (should be after custom close)." << std::endl; }};void demo_shared_ptr_custom_resource() { // shared_ptr在构造时直接传入删除器，类型是std::shared_ptr std::shared_ptr conn( new NetworkConnection("example.com", 8080), [](NetworkConnection* nc) { if (nc) { std::cout << "DEBUG: Custom deleter for NetworkConnection called." <close(); // 调用资源的特定关闭方法 delete nc; // 然后释放内存 } } ); if (conn) { conn->send("Hello, server!"); } std::cout << "INFO: conn shared_ptr scope ending." << std::endl; // 当conn的引用计数归零时，lambda删除器会被调用}// 另一个shared_ptr例子：管理std::ofstreamvoid demo_shared_ptr_ofstream() { std::shared_ptr outFile( new std::ofstream("output.txt"), [](std::ofstream* os) { if (os && os->is_open()) { std::cout << "DEBUG: Custom deleter closing std::ofstream." <close(); delete os; } else if (os) { delete os; } } ); if (outFile && outFile->is_open()) { *outFile << "Writing something to output.txtn"; } std::cout << "INFO: outFile shared_ptr scope ending." << std::endl;}int main() { demo_unique_ptr_functor(); std::cout << "------------------------n"; demo_unique_ptr_lambda_thread(); std::cout << "------------------------n"; demo_unique_ptr_func_ptr(); std::cout << "------------------------n"; demo_shared_ptr_custom_resource(); std::cout << "------------------------n"; demo_shared_ptr_ofstream(); return 0;}
可以看到，自定义删除器极大地扩展了智能指针的能力，让它们能够成为管理各种类型资源的通用工具，而不仅仅是内存。
C++智能指针自定义删除器的核心价值：超越内存管理的资源封装
说实话，刚接触智能指针时，很多人（包括我）可能只把它当成
new
/
delete
的自动版本。但随着项目深入，你会发现很多资源并非简单地用
delete
就能搞定。比如文件句柄需要
fclose
，网络套接字需要
closesocket
，互斥锁需要
unlock
，甚至一些C库分配的内存需要
free
而不是
delete
。这些非内存资源的清理逻辑，如果每次都靠手动调用，那简直是噩梦。一个不小心，资源泄漏就发生了，调试起来非常痛苦。
自定义删除器就是为了解决这些痛点而生的。它把资源获取（Resource Acquisition）和资源释放（Resource Release）紧密地绑定在一起，完美地体现了RAII（Resource Acquisition Is Initialization）原则。当我拿到一个文件句柄，我立刻把它包装进一个带有
fclose
删除器的
unique_ptr
里，那么无论我的代码在中间出了什么岔子，抛了异常也好，提前返回也罢，只要这个
unique_ptr
离开作用域，文件句柄就一定会被妥善关闭。这不仅大大提升了代码的健壮性和异常安全性，也让资源管理逻辑变得更加清晰和集中。从某种意义上说，它将智能指针从一个“内存管家”升级成了“全能资源管理员”。
C++智能指针自定义删除器选择指南：函数对象、Lambda与函数指针的优劣
在选择自定义删除器的实现方式时，我通常会根据实际需求来权衡。这三种方式各有千秋，没有绝对的“最佳”，只有“最适合”。
函数对象（Functor）：这是最灵活的一种方式，因为它本质上是一个类。你可以让它携带状态，比如在删除器中记录一些日志信息，或者根据内部状态决定不同的清理策略。如果你的清理逻辑比较复杂，或者希望这个删除器可以在多个地方复用，并且需要一些配置参数，那么函数对象是首选。它的缺点是需要额外定义一个
struct
或
class
，对于简单的清理任务来说，可能会显得有点“杀鸡用牛刀”。另外，对于
std::unique_ptr
，函数对象的类型会成为
unique_ptr
类型的一部分，这在模板元编程或类型推导时可能需要额外注意。
Lambda 表达式：这是我个人最常用的一种方式，尤其是在C++11及更高版本中。Lambda表达式的优势在于简洁和局部性。你可以在需要的地方直接定义清理逻辑，并且可以轻松捕获当前作用域的变量，这使得它非常适合处理那些与特定上下文相关的资源清理。例如，一个删除器可能需要访问某个日志对象来记录关闭信息，或者需要一个ID来标识正在关闭的资源。Lambda的缺点嘛，对于
std::unique_ptr
，你可能需要使用
decltype
来获取lambda的类型，这让代码看起来略微复杂一点点。但对于
std::shared_ptr
，它简直是完美搭配，因为
shared_ptr
的删除器类型是擦除的。
函数指针：这是最传统、最简单的方式，适用于那些无状态、通用的清理函数。比如，如果你需要用
free()
来释放
malloc()
分配的内存，那么直接传入
&free
作为删除器就非常直观。它的优点是类型简单，开销小。但缺点也很明显，它不能捕获任何状态，所以如果你的清理逻辑依赖于某些运行时数据，函数指针就无能为力了。通常，我只会在清理操作非常标准且不依赖任何上下文时才考虑它。
总结一下，如果清理逻辑简单且无状态，函数指针或简单lambda就够了。如果需要捕获上下文或处理复杂状态，lambda通常是我的首选。而如果删除器本身需要高度复用、配置或者承载复杂逻辑，那么函数对象无疑是更强大的工具。
C++智能指针自定义删除器：避免常见错误与提升代码健壮性的实践
自定义删除器虽然强大，但用不好也容易踩坑。我在实际开发中就遇到过一些问题，总结下来，有些陷阱是需要特别留意的，同时也有一些实践能让代码更健壮。
常见陷阱：
删除器不处理
nullptr
： 这是一个很常见的疏忽。智能指针在析构时，可能其内部管理的指针已经是
nullptr
（例如，它可能被
release()
了，或者在构造时就传入了
nullptr
）。你的自定义删除器必须能安全地处理
nullptr
，否则可能导致
以上就是C++智能指针自定义删除器 资源清理回调的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1473924.html
微信扫一扫 
支付宝扫一扫 
