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

#include <iostream>
#include <memory>
#include <cstdio> // 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<FILE, decltype(file_closer)> 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<FILE, FileDeleter> 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<FILE, decltype(&close_my_file)> 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;
}

// 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<FILE> 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<FILE> 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<FILE> 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<char*>(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<char> sp_buffer(buffer, [](char* p) noexcept {
        std::cout << "Freeing malloc'd buffer: " << static_cast<void*>(p) << std::endl;
        std::free(p);
    });
    std::cout << "shared_ptr malloc/free demo end." << std::endl;

    return 0;
}