自定义删除器解决了智能指针管理非堆内存资源的问题，使资源能自动释放。1. 它扩展了智能指针的适用范围，可管理文件句柄、网络连接等系统资源；2. 避免资源泄漏，确保异常安全下的资源释放；3. 与c api无缝集成，简化第三方库资源管理；4. 明确所有权语义，提升代码可读性。unique_ptr的删除器是类型的一部分，适用于独占所有权且无额外内存开销；shared_ptr的删除器通过构造函数传入，支持类型擦除，适用于共享所有权和多态场景。使用时需遵循最佳实践，如标记noexcept以避免析构异常导致程序终止。
C++中实现自定义删除器，本质上就是告诉智能指针，当它所管理的资源不再需要时，应该如何进行清理，而不是简单地调用delete。这极大地扩展了智能指针的管理范围，使其不仅限于堆内存，还能优雅地处理文件句柄、网络连接、互斥锁、C风格分配的内存等各种系统资源，确保资源的安全自动释放。
解决方案
在C++中，std::unique_ptr和std::shared_ptr都支持自定义删除器，但它们的实现方式和对智能指针类型的影响有所不同。
对于 std::unique_ptr：
立即学习“C++免费学习笔记（深入）”；
unique_ptr的自定义删除器是通过模板参数指定的。这意味着删除器的类型会成为unique_ptr类型的一部分。
#include #include #include // For FILE* and fclose// 1. 使用Lambda表达式作为删除器 (最常用且简洁)// 适用于简单、一次性的清理逻辑void demo_unique_ptr_lambda() { std::cout << "--- unique_ptr with Lambda Deleter ---" << std::endl; // 打开一个文件 FILE* file = std::fopen("test_lambda.txt", "w"); // 定义一个lambda作为删除器，捕获file指针并调用fclose // 注意：lambda必须是noexcept的，否则可能导致程序终止 auto file_closer = [](FILE* f) noexcept { if (f) { std::cout << "Closing file (lambda): " << f << std::endl; std::fclose(f); } }; // unique_ptr的模板参数需要指定删除器类型 std::unique_ptr up_file(file, file_closer); if (up_file) { std::fputs("Hello from unique_ptr lambda!", up_file.get()); } // up_file超出作用域时，file_closer会被调用 std::cout << "unique_ptr lambda demo end." << std::endl;}// 2. 使用函数对象（Functor）作为删除器 (适用于复杂或可复用的清理逻辑)// 定义一个结构体，重载operator()struct FileDeleter { void operator()(FILE* f) const noexcept { if (f) { std::cout << "Closing file (functor): " << f << std::endl; std::fclose(f); } }};void demo_unique_ptr_functor() { std::cout << "n--- unique_ptr with Functor Deleter ---" << std::endl; FILE* file = std::fopen("test_functor.txt", "w"); // unique_ptr的模板参数需要指定删除器类型 std::unique_ptr up_file(file, FileDeleter()); if (up_file) { std::fputs("Hello from unique_ptr functor!", up_file.get()); } std::cout << "unique_ptr functor demo end." << std::endl;}// 3. 使用函数指针作为删除器 (适用于C风格的清理函数)// 注意：函数指针的类型也必须作为模板参数void close_my_file(FILE* f) noexcept { if (f) { std::cout << "Closing file (function pointer): " << f << std::endl; std::fclose(f); }}void demo_unique_ptr_func_ptr() { std::cout << "n--- unique_ptr with Function Pointer Deleter ---" << std::endl; FILE* file = std::fopen("test_func_ptr.txt", "w"); // unique_ptr的模板参数需要指定删除器类型 (这里是 void(*)(FILE*)) std::unique_ptr up_file(file, &close_my_file); if (up_file) { std::fputs("Hello from unique_ptr function pointer!", up_file.get()); } std::cout << "unique_ptr function pointer demo end." << std::endl;}
对于 std::shared_ptr：
shared_ptr的自定义删除器作为构造函数的额外参数传入。这意味着删除器的类型不会成为shared_ptr类型的一部分，这使得shared_ptr在处理不同清理逻辑的资源时，类型保持一致，更具多态性。
// 1. 使用Lambda表达式作为删除器 (最常用且简洁)void demo_shared_ptr_lambda() { std::cout << "n--- shared_ptr with Lambda Deleter ---" << std::endl; FILE* file = std::fopen("test_shared_lambda.txt", "w"); // shared_ptr的删除器作为构造函数的第二个参数传入 // 注意：这里的lambda同样应该是noexcept的 std::shared_ptr sp_file(file, [](FILE* f) noexcept { if (f) { std::cout << "Closing file (shared_ptr lambda): " << f << std::endl; std::fclose(f); } }); if (sp_file) { std::fputs("Hello from shared_ptr lambda!", sp_file.get()); } // sp_file超出作用域且引用计数归零时，lambda会被调用 std::cout << "shared_ptr lambda demo end." << std::endl;}// 2. 使用函数对象（Functor）作为删除器struct SharedFileDeleter { void operator()(FILE* f) const noexcept { if (f) { std::cout << "Closing file (shared_ptr functor): " << f << std::endl; std::fclose(f); } }};void demo_shared_ptr_functor() { std::cout << "n--- shared_ptr with Functor Deleter ---" << std::endl; FILE* file = std::fopen("test_shared_functor.txt", "w"); std::shared_ptr sp_file(file, SharedFileDeleter()); if (sp_file) { std::fputs("Hello from shared_ptr functor!", sp_file.get()); } std::cout << "shared_ptr functor demo end." << std::endl;}// 3. 使用函数指针作为删除器void shared_close_my_file(FILE* f) noexcept { if (f) { std::cout << "Closing file (shared_ptr function pointer): " << f << std::endl; std::fclose(f); }}void demo_shared_ptr_func_ptr() { std::cout << "n--- shared_ptr with Function Pointer Deleter ---" << std::endl; FILE* file = std::fopen("test_shared_func_ptr.txt", "w"); std::shared_ptr sp_file(file, &shared_close_my_file); if (sp_file) { std::fputs("Hello from shared_ptr function pointer!", sp_file.get()); } std::cout << "shared_ptr function pointer demo end." << std::endl;}// 实际运行代码int main() { demo_unique_ptr_lambda(); demo_unique_ptr_functor(); demo_unique_ptr_func_ptr(); demo_shared_ptr_lambda(); demo_shared_ptr_functor(); demo_shared_ptr_func_ptr(); // 演示一个malloc/free的例子 std::cout << "n--- shared_ptr with malloc/free ---" << std::endl; char* buffer = static_cast(std::malloc(100)); if (buffer) { std::strcpy(buffer, "Hello from malloc'd buffer!"); std::cout << "Buffer content: " << buffer << std::endl; } // 使用lambda作为删除器来调用free std::shared_ptr sp_buffer(buffer, [](char* p) noexcept { std::cout << "Freeing malloc'd buffer: " << static_cast(p) << std::endl; std::free(p); }); std::cout << "shared_ptr malloc/free demo end." << std::endl; return 0;}
为什么智能指针需要自定义删除器？它解决了哪些常见痛点？
说实话，刚开始接触智能指针时，很多人（包括我）可能只把它看作是new和delete的自动化工具，避免内存泄漏。但随着项目复杂度的提升，你会发现程序中需要管理的资源远不止堆内存。文件句柄、数据库连接、网络套接字、互斥锁、动态加载的DLL/SO库，甚至是C语言风格的malloc/free分配的内存，它们都有自己的“清理”方式，不一定就是简单的delete。
自定义删除器，正是智能指针能够超越传统内存管理，拥抱更广泛RAII（Resource Acquisition Is Initialization）原则的关键。它解决了以下几个核心痛点：
硅基智能
基于Web3.0的元宇宙，去中心化的互联网，高质量、沉浸式元宇宙直播平台，用数字化重新定义直播
62 查看详情 资源管理的通用性： 没有自定义删除器，智能指针就只能管new出来的内存。但有了它，你可以用unique_ptr或shared_ptr来管理任何需要“关闭”、“释放”或“销毁”的资源。比如，std::unique_ptr就能完美管理C风格的文件流。这极大提升了代码的通用性和复用性。避免资源泄漏： 这是RAII的核心优势。无论函数是正常返回、提前退出，还是因为异常抛出，只要智能指针超出作用域，其绑定的自定义删除器就会被自动调用，确保资源总是得到释放。这比手动在每个可能的退出点调用清理函数要安全、简洁得多，也大大降低了出错的概率。我常常看到有人在复杂的函数逻辑中忘记某个分支的资源释放，有了智能指针和自定义删除器，这种担忧就少了很多。与C API的无缝集成： 很多高性能或底层库都是用C语言编写的，它们通常返回原始指针，并要求你调用特定的_close()或_destroy()函数来释放资源。自定义删除器就像一座桥梁，让这些C风格的资源也能享受到C++智能指针的便利和安全性，而无需为每个资源类型都手写一个RAII包装类。这简直是福音，特别是当你在一个C++项目中需要大量使用C库时。清晰的所有权语义： 当你用智能指针管理一个非内存资源时，自定义删除器明确地告诉了读者这个资源的所有权如何被管理，以及它在生命周期结束时会发生什么。这比裸指针和分散的close()调用要清晰得多。
std::unique_ptr与std::shared_ptr在自定义删除器上的差异及选择考量
这俩哥们儿在处理自定义删除器时，确实有点儿不同，理解这些差异对于你选择合适的智能指针至关重要。我个人觉得，这体现了它们各自设计哲学上的细微差别。
std::unique_ptr：
类型绑定： 最大的特点就是，自定义删除器的类型是unique_ptr类型的一部分。比如，std::unique_ptr和std::unique_ptr是两种完全不同的类型。这意味着如果你有一个函数接受unique_ptr，它必须精确匹配这个类型，包括删除器类型。这在编写模板代码或者需要存储不同删除器类型的unique_ptr集合时，可能会带来一些不便。内存开销： 这是它的一个巨大优势。如果你的自定义删除器是“无状态的”（比如一个空的函数对象、一个不捕获任何变量的lambda，或者一个函数指针），那么unique_ptr的实际大小通常和裸指针一样，几乎没有额外的内存开销。这是因为编译器可以优化掉存储删除器对象本身的空间。这种“零开销抽象”是C++设计哲学的一个体现，非常酷。所有权语义： 严格的独占所有权。一个资源只能被一个unique_ptr实例管理。当这个unique_ptr被销毁或转移时，资源就会被释放或所有权转移。
std::shared_ptr：
类型擦除： shared_ptr的自定义删除器作为构造函数的额外参数传入，它的类型不会成为shared_ptr类型的一部分。这意味着std::shared_ptr无论你给它传入的是lambda、函数对象还是函数指针作为删除器，它的类型始终是std::shared_ptr。这种“类型擦除”的特性让shared_ptr在多态场景下更加灵活，你可以把不同删除器管理的shared_ptr实例放到同一个std::vector<std::shared_ptr>中。内存开销： shared_ptr为了实现引用计数和类型擦除，总是会有一个额外的控制块（control block）开销。这个控制块会存储引用计数、弱引用计数以及自定义删除器（如果存在的话）。所以，即使你的删除器是无状态的，shared_ptr的大小也总是比裸指针大，通常是裸指针的两倍（一个指针指向资源，一个指针指向控制块）。所有权语义： 共享所有权。多个shared_ptr实例可以共同管理同一个资源。只有当所有指向该资源的shared_ptr实例都被销毁，引用计数归零时，自定义删除器才会被调用。
选择考量：
我个人的经验是，优先考虑std::unique_ptr。如果一个资源确实只有单一所有者，并且不需要共享，那么unique_ptr是更高效、更清晰的选择，尤其是它在无状态删除器下的零开销特性非常吸引人。
只有当你明确需要以下特性时，才转向std::shared_ptr：
共享所有权： 多个对象需要共同管理一个资源的生命周期。删除器类型擦除： 你需要将不同删除器管理的同类型资源存储在同一个容器中，或者在多态场景下传递它们，而不想让删除器类型污染智能指针的类型。
简而言之，unique_ptr是默认选项，shared_ptr是当共享所有权或类型擦除成为必要时的解决方案。
实现自定义删除器的最佳实践与常见陷阱
实现自定义删除器虽然强大，但也有一些需要注意的地方，否则可能会踩到一些坑。我在这里总结了一些经验和常见的错误，希望能帮助你避开它们。
最佳实践：
使用 noexcept 标记删除器： 这是最最重要的一点！自定义删除器在智能指针析构时被调用，如果此时删除器抛出异常，会导致程序立即终止（std::terminate）。这是C++标准规定的，因为它无法在析构函数中处理异常。所以，无论你用lambda、函数对象还是函数指针，务必确保你的删除器是noexcept的。如果
以上就是C++中如何实现自定义删除器 智能指针高级用法解析的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/475099.html
微信扫一扫 
支付宝扫一扫 
