自定义C++智能指针删除器：函数对象与lambda示例

自定义C++智能指针的删除器，是通过赋予智能指针在对象生命周期结束时释放资源的权力，以适应复杂资源管理需求。1. 对于std::unique_ptr，删除器类型是其类型定义的一部分，在编译时确定，提供更强类型安全性和运行时性能优化；2. 对于std::shared_ptr，删除器在构造时指定，所有共享同一资源的实例共用该删除器，提供运行时灵活性；3. 删除器可通过函数对象或Lambda表达式实现，如关闭文件、释放非new分配内存、系统资源等；4. 处理删除器异常时，应在删除器内部捕获并处理异常，避免程序意外终止；5. unique_ptr适用于唯一所有权场景，shared_ptr适用于资源共享场景。

自定义 C++ 智能指针的删除器，本质上就是赋予智能指针在对象生命周期结束时，如何释放其所管理资源的权力。这允许我们超越默认的 delete 操作，以适应各种复杂的资源管理需求。

解决方案

C++ 智能指针（std::unique_ptr 和 std::shared_ptr）提供了自定义删除器的机制。关键在于模板参数。

• std::unique_ptr: 删除器类型是 unique_ptr 类型定义的一部分。这意味着 unique_ptr 的类型会因为删除器的不同而不同。这使得编译器可以进行更强的类型检查，并且通常可以避免运行时的性能损失。
• std::shared_ptr: 删除器在构造 shared_ptr 时指定。所有使用相同原始指针的 shared_ptr 实例共享相同的删除器。

函数对象 (Functor)

函数对象是一个类，它重载了函数调用操作符 operator()。 我们可以创建一个函数对象，在其 operator() 中定义我们的资源释放逻辑。

#include <iostream>
#include <memory>

// 自定义删除器：文件关闭
struct FileCloser {
    void operator()(FILE* file) const {
        if (file) {
            fclose(file);
            std::cout << "File closed.\n";
        }
    }
};

int main() {
    // 使用函数对象作为删除器
    std::unique_ptr<FILE, FileCloser> file(fopen("example.txt", "w"), FileCloser());

    if (file) {
        fprintf(file.get(), "Hello, world!\n");
    } // 文件将在 file 离开作用域时自动关闭

    return 0;
}

在这个例子中，FileCloser 是一个函数对象，它接受一个 FILE* 指针并在其 operator() 中关闭文件。std::unique_ptr 被声明为 std::unique_ptr<FILE, FileCloser>，这意味着它将使用 FileCloser 来删除它所管理的 FILE* 指针。

Lambda 表达式

Lambda 表达式提供了一种更简洁的方式来定义删除器，特别是对于简单的资源释放逻辑。

#include <iostream>
#include <memory>

int main() {
    // 使用 Lambda 表达式作为删除器
    std::unique_ptr<FILE, void(*)(FILE*)> file(fopen("example.txt", "w"), [](FILE* f){
        if (f) {
            fclose(f);
            std::cout << "File closed by lambda.\n";
        }
    });

    if (file) {
        fprintf(file.get(), "Hello from lambda!\n");
    }

    return 0;
}

这里，我们直接在 unique_ptr 的构造函数中提供了一个 lambda 表达式作为删除器。注意 unique_ptr 的类型定义现在是 std::unique_ptr<FILE, void(*)(FILE*)>。 这是因为 lambda 表达式会被转换为一个函数指针，所以我们需要显式地指定函数指针的类型。 如果lambda没有捕获任何变量，它可以隐式转换为函数指针。

std::shared_ptr 中的删除器

shared_ptr 的删除器是在构造函数中指定的，并且所有指向同一资源的 shared_ptr 实例共享相同的删除器。

#include <iostream>
#include <memory>

int main() {
    FILE* file = fopen("example.txt", "w");
    if (!file) {
        std::cerr << "Failed to open file.\n";
        return 1;
    }

    // 使用 shared_ptr 和 Lambda 表达式
    std::shared_ptr<FILE> sharedFile(file, [](FILE* f){
        if (f) {
            fclose(f);
            std::cout << "File closed by shared_ptr.\n";
        }
    });

    fprintf(sharedFile.get(), "Hello from shared_ptr!\n");

    // 当 sharedFile 离开作用域时，文件将被关闭
    return 0;
}

在这个例子中，我们创建了一个 shared_ptr，它管理一个 FILE* 指针，并使用一个 lambda 表达式作为删除器。当最后一个指向该文件的 shared_ptr 实例离开作用域时，lambda 表达式将被调用，文件将被关闭。

何时应该自定义智能指针删除器？

当需要执行的资源释放操作不仅仅是简单的 delete 时，就需要自定义删除器。 典型场景包括：

• 释放非 new 分配的内存: 例如，使用 malloc 分配的内存需要使用 free 释放。
• 释放文件句柄、网络连接等系统资源: 这些资源需要使用特定的系统调用来释放，例如 fclose、closesocket 等。
• 释放 COM 对象: COM 对象需要使用 Release 方法来释放。
• 执行一些额外的清理操作: 例如，在对象销毁时记录日志。

自定义删除器可以确保资源得到正确释放，避免内存泄漏和其他资源泄漏问题。

unique_ptr 和 shared_ptr 在删除器使用上的区别是什么？

unique_ptr 的删除器类型是其类型定义的一部分，而 shared_ptr 的删除器是在构造时指定的。 这导致了一些重要的区别：

• 类型安全性: unique_ptr 提供了更强的类型安全性，因为删除器的类型是在编译时确定的。这可以避免一些运行时错误。
• 性能: unique_ptr 通常比 shared_ptr 更有效率，因为它不需要维护引用计数。此外，如果删除器是一个空函数对象（即，没有任何状态），编译器可以对其进行优化，从而完全消除删除器的开销。
• 灵活性: shared_ptr 提供了更大的灵活性，因为它允许在运行时指定删除器。这对于需要在不同情况下使用不同删除器的场景非常有用。

选择使用 unique_ptr 还是 shared_ptr 取决于具体的资源管理需求。通常，如果资源的所有权是唯一的，则应该使用 unique_ptr。 如果资源需要被多个对象共享，则应该使用 shared_ptr。

如何处理删除器抛出异常的情况？

如果删除器抛出异常，程序通常会终止。 这是因为在对象销毁过程中抛出异常可能会导致未定义的行为。 为了避免这种情况，应该确保删除器不会抛出异常，或者至少要捕获并处理所有可能抛出的异常。

一种常见的做法是在删除器中使用 try-catch 块来捕获异常并记录错误信息。

#include <iostream>
#include <memory>

struct BadFileCloser {
    void operator()(FILE* file) const {
        if (file) {
            if (rand() % 2 == 0) {
                fclose(file);
                std::cout << "File closed.\n";
            } else {
                throw std::runtime_error("Simulated file close error!");
            }
        }
    }
};


int main() {
    FILE* file = fopen("example.txt", "w");
    if (!file) {
        std::cerr << "Failed to open file.\n";
        return 1;
    }

    std::unique_ptr<FILE, void(*)(FILE*)> safeFile(file, [](FILE* f) {
        try {
            if (f) {
                fclose(f);
                std::cout << "File closed safely.\n";
            }
        } catch (const std::exception& e) {
            std::cerr << "Exception during file close: " << e.what() << '\n';
            // 可以选择记录错误日志或采取其他补救措施
        } catch (...) {
            std::cerr << "Unknown exception during file close!\n";
        }
    });

    fprintf(safeFile.get(), "This will be closed safely (hopefully).\n");

    return 0;
}

在这个例子中，lambda删除器捕获了 fclose 可能抛出的任何异常，并打印了错误信息。 这可以防止程序意外终止。

请注意，即使捕获了异常，程序的状态也可能是不确定的。 因此，最好设计删除器，使其尽可能避免抛出异常。