C++中如何实现自定义删除器 智能指针高级用法解析

自定义删除器解决了智能指针管理非堆内存资源的问题，使资源能自动释放。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）原则的关键。它解决了以下几个核心痛点：

PicWish

推荐！专业的AI抠图修图，支持格式转化

下载

1. 资源管理的通用性： 没有自定义删除器，智能指针就只能管new出来的内存。但有了它，你可以用unique_ptr或shared_ptr来管理任何需要“关闭”、“释放”或“销毁”的资源。比如，std::unique_ptr就能完美管理C风格的文件流。这极大提升了代码的通用性和复用性。
2. 避免资源泄漏： 这是RAII的核心优势。无论函数是正常返回、提前退出，还是因为异常抛出，只要智能指针超出作用域，其绑定的自定义删除器就会被自动调用，确保资源总是得到释放。这比手动在每个可能的退出点调用清理函数要安全、简洁得多，也大大降低了出错的概率。我常常看到有人在复杂的函数逻辑中忘记某个分支的资源释放，有了智能指针和自定义删除器，这种担忧就少了很多。
3. 与C API的无缝集成： 很多高性能或底层库都是用C语言编写的，它们通常返回原始指针，并要求你调用特定的_close()或_destroy()函数来释放资源。自定义删除器就像一座桥梁，让这些C风格的资源也能享受到C++智能指针的便利和安全性，而无需为每个资源类型都手写一个RAII包装类。这简直是福音，特别是当你在一个C++项目中需要大量使用C库时。
4. 清晰的所有权语义： 当你用智能指针管理一个非内存资源时，自定义删除器明确地告诉了读者这个资源的所有权如何被管理，以及它在生命周期结束时会发生什么。这比裸指针和分散的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<:shared_ptr>>中。
• 内存开销： shared_ptr为了实现引用计数和类型擦除，总是会有一个额外的控制块（control block）开销。这个控制块会存储引用计数、弱引用计数以及自定义删除器（如果存在的话）。所以，即使你的删除器是无状态的，shared_ptr的大小也总是比裸指针大，通常是裸指针的两倍（一个指针指向资源，一个指针指向控制块）。
• 所有权语义： 共享所有权。多个shared_ptr实例可以共同管理同一个资源。只有当所有指向该资源的shared_ptr实例都被销毁，引用计数归零时，自定义删除器才会被调用。

选择考量：

我个人的经验是，优先考虑std::unique_ptr。如果一个资源确实只有单一所有者，并且不需要共享，那么unique_ptr是更高效、更清晰的选择，尤其是它在无状态删除器下的零开销特性非常吸引人。

只有当你明确需要以下特性时，才转向std::shared_ptr：

• 共享所有权： 多个对象需要共同管理一个资源的生命周期。
• 删除器类型擦除： 你需要将不同删除器管理的同类型资源存储在同一个容器中，或者在多态场景下传递它们，而不想让删除器类型污染智能指针的类型。

简而言之，unique_ptr是默认选项，shared_ptr是当共享所有权或类型擦除成为必要时的解决方案。

实现自定义删除器的最佳实践与常见陷阱

实现自定义删除器虽然强大，但也有一些需要注意的地方，否则可能会踩到一些坑。我在这里总结了一些经验和常见的错误，希望能帮助你避开它们。

最佳实践：

1. 使用 noexcept 标记删除器： 这是最最重要的一点！自定义删除器在智能指针析构时被调用，如果此时删除器抛出异常，会导致程序立即终止（std::terminate）。这是C++标准规定的，因为它无法在析构函数中处理异常。所以，无论你用lambda、函数对象还是函数指针，务必确保你的删除器是noexcept的。如果