C++如何使用智能指针管理文件句柄

fclose

CloseHandle

std::unique_ptr

std::shared_ptr

#include <cstdio> // For FILE, fopen, fclose
#include <memory>   // For std::unique_ptr
#include <iostream> // For std::cout, std::cerr

// 1. 定义一个自定义删除器（lambda表达式）
// 这是一个非常简洁的方式，直接在unique_ptr构造时提供
auto file_deleter = [](FILE* file_ptr) {
    if (file_ptr) {
        std::cout << "关闭文件句柄..." << std::endl;
        fclose(file_ptr);
    }
};

// 2. 使用std::unique_ptr管理FILE*
// unique_ptr的模板参数需要指定类型和删除器类型
using UniqueFilePtr = std::unique_ptr<FILE, decltype(file_deleter)>;

// 示例函数
void process_file(const char* filename) {
    // 尝试打开文件
    FILE* raw_file_ptr = fopen(filename, "r");

    // 检查是否成功打开
    if (!raw_file_ptr) {
        std::cerr << "错误：无法打开文件 " << filename << std::endl;
        return;
    }

    // 将原始文件句柄包装到智能指针中
    // unique_ptr会在其生命周期结束时（函数返回或异常抛出）自动调用file_deleter
    UniqueFilePtr file_guard(raw_file_ptr, file_deleter);

    // 此时，文件句柄raw_file_ptr的所有权已经转移给了file_guard
    // 我们可以像使用普通FILE*一样使用file_guard.get()
    char buffer[256];
    if (fgets(buffer, sizeof(buffer), file_guard.get())) {
        std::cout << "文件内容第一行: " << buffer;
    } else {
        std::cerr << "无法读取文件内容或文件为空。" << std::endl;
    }

    // 无需手动调用fclose(raw_file_ptr);
    // 当file_guard离开作用域时，它会自动关闭文件。
    std::cout << "文件处理完成。" << std::endl;
}

int main() {
    // 创建一个测试文件
    FILE* test_file = fopen("test.txt", "w");
    if (test_file) {
        fprintf(test_file, "Hello, Smart Pointers!\n");
        fprintf(test_file, "This is a test file.\n");
        fclose(test_file);
    }

    process_file("test.txt");
    std::cout << "\n--- 尝试处理一个不存在的文件 ---\n";
    process_file("nonexistent.txt");

    return 0;
}

std::unique_ptr

FILE*

std::shared_ptr

UniqueFilePtr

std::shared_ptr<FILE>

std::unique_ptr

FILE* fp = fopen("file.txt", "r");

fclose(fp);

fclose

try-catch

fclose

finally

fclose

fclose

std::unique_ptr

FILE*

FILE*

fclose

// Lambda表达式作为删除器，简洁明了
auto c_file_deleter = [](FILE* fp) {
    if (fp) {
        std::cout << "关闭 C 文件句柄: " << fp << std::endl;
        fclose(fp);
    }
};
using CFilePtr = std::unique_ptr<FILE, decltype(c_file_deleter)>;

HANDLE

CreateFile

CloseHandle

#ifdef _WIN32
#include <windows.h> // For HANDLE, CreateFile, CloseHandle
// 定义一个结构体作为删除器，可以更清晰地命名和封装
struct WinHandleDeleter {
    void operator()(HANDLE handle) const {
        if (handle && handle != INVALID_HANDLE_VALUE) {
            std::cout << "关闭 Windows 文件句柄: " << handle << std::endl;
            CloseHandle(handle);
        }
    }
};
using WinFileHandlePtr = std::unique_ptr<void, WinHandleDeleter>; // HANDLE实际上是void*
#endif

// 示例用法 (仅在Windows下编译)
/*
#ifdef _WIN32
void process_win_file(const wchar_t* filename) {
    HANDLE hFile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ,
                               nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
    if (hFile == INVALID_HANDLE_VALUE) {
        std::wcerr << L"错误：无法打开文件 " << filename << std::endl;
        return;
    }
    WinFileHandlePtr file_guard(hFile, WinHandleDeleter{});
    // ... 使用 file_guard.get() 进行文件操作 ...
    std::wcout << L"Windows 文件处理完成。" << std::endl;
}
#endif
*/

HANDLE

void*

std::unique_ptr<void, WinHandleDeleter>

HANDLE

int

open

close

#ifndef _WIN32
#include <unistd.h> // For close
#include <fcntl.h>  // For open
// 函数对象作为删除器
struct UnixFdDeleter {
    void operator()(int fd) const {
        if (fd >= 0) {
            std::cout << "关闭 Unix 文件描述符: " << fd << std::endl;
            close(fd);
        }
    }
};
using UnixFileDescriptorPtr = std::unique_ptr<int, UnixFdDeleter>;
#endif

// 示例用法 (仅在Linux/Unix下编译)
/*
#ifndef _WIN32
void process_unix_file(const char* filename) {
    int fd = open(filename, O_RDONLY);
    if (fd < 0) {
        std::cerr << "错误：无法打开文件 " << filename << std::endl;
        return;
    }
    UnixFileDescriptorPtr fd_guard(&fd, UnixFdDeleter{}); // 注意这里传入的是地址
    // ... 使用 *fd_guard.get() 进行文件操作 ...
    std::cout << "Unix 文件处理完成。" << std::endl;
}
#endif
*/
这里`std::unique_ptr<int, UnixFdDeleter>`有点特殊，因为`int`不是指针类型。通常，`std::unique_ptr`设计来管理堆上的对象，其第一个模板参数是指针类型。如果我们要管理一个`int`类型的文件描述符，通常会用一个`std::unique_ptr<int, UnixFdDeleter>`，但其内部实际上存储的是一个指向`int`的指针。在实际使用时，我们可能需要将`int*`传递给`unique_ptr`，或者更简洁地，直接使用`std::unique_ptr<void, UnixFdDeleter>`并让deleter知道如何处理这个`void*`指向的`int`。不过，为了避免这种类型上的不匹配，很多时候我们会选择封装一层，或者直接用`unique_ptr<FILE, ...>`这种更符合其设计初衷的方式。对于原始的`int`文件描述符，可能自定义一个RAII类会更直接。

但是，标准库的`unique_ptr`确实可以管理非指针类型，只要删除器能正确处理。一个更符合`unique_ptr`设计的方式是，如果资源本身不是指针，通常我们会让`unique_ptr`管理一个指向该资源的指针。但对于`int`这种直接作为句柄的，我们往往会看到`unique_ptr<int, Deleter>`的用法，这实际上是利用了`unique_ptr`的第二个模板参数可以改变其内部存储方式的能力（`std::default_delete`是空类，不会增加大小，但自定义删除器会增加大小，这会影响`unique_ptr`的内存布局）。

### 智能指针管理文件句柄时，有哪些常见陷阱和最佳实践？

即便智能指针大大简化了资源管理，但它也不是万能的银弹，使用不当仍可能引入问题。了解这些陷阱并遵循最佳实践，能帮助我们写出更健壮、更高效的代码。

**常见陷阱：**

1.  **忘记检查`fopen`/`CreateFile`/`open`的返回值：** 智能指针只能管理成功获取的资源。如果`fopen`返回`nullptr`（表示文件打开失败），而你直接用这个`nullptr`去构造`std::unique_ptr`，虽然不会立即崩溃，但智能指针管理的是一个无效的句柄，并且在析构时，你的删除器可能会尝试关闭一个`nullptr`，虽然我们的删除器里有`if (ptr)`检查，但这掩盖了资源获取失败的真正问题。**最佳实践是，始终在构造智能指针之前检查原始资源获取函数的返回值。**

2.  **删除器签名不匹配：** `std::unique_ptr`的删除器必须能够接受智能指针所管理类型的指针作为参数。例如，`std::unique_ptr<FILE, Deleter>`，那么`Deleter`的`operator()`或函数签名必须是`void(FILE*)`。如果删除器期望的是`const FILE*`或`FILE&`，就会导致编译错误。

3.  **混合使用原始指针和智能指针：** 一旦资源被智能指针管理，就应该尽量通过智能指针来访问（`ptr.get()`），而不是保留一个原始指针副本并继续使用它。如果原始指针被手动`fclose`，而智能指针又在其生命周期结束时再次尝试关闭同一个句柄，这将导致“双重释放”（double free）错误，这是非常危险的未定义行为。

4.  **`std::shared_ptr`的滥用：** 对于文件句柄这种通常是独占的资源，`std::unique_ptr`是首选。只有在确实需要多个所有者共享同一个文件句柄的场景（比如多个线程或模块需要同时访问同一个打开的文件，且文件生命周期由它们共同决定）时，才考虑`std::shared_ptr`。`std::shared_ptr`会引入引用计数开销，对于不需要共享所有权的场景来说是多余的。

5.  **删除器抛出异常：** 智能指针的析构函数通常是`noexcept`的，这意味着它们不应该抛出异常。如果你的自定义删除器在执行关闭操作时抛出异常，这将导致程序立即终止（`std::terminate`），这通常不是我们期望的行为。**最佳实践是，删除器应该尽可能地`noexcept`，并且内部的资源释放操作也应该是安全的，不抛出异常。** 例如，`fclose`和`CloseHandle`通常不会抛出C++异常。

**最佳实践：**

1.  **优先使用`std::unique_ptr`：** 对于文件句柄这种独占性资源，`std::unique_ptr`是表达所有权语义的最佳选择。它没有`std::shared_ptr`的引用计数开销，且能清晰地表明资源生命周期由单个智能指针管理。

2.  **将删除器定义为lambda或结构体：** Lambda表达式非常适合简洁的删除器，特别是当删除逻辑不复杂时。如果删除逻辑较复杂，或者需要在多个地方复用，定义一个带有`operator()`的结构体（函数对象）会更清晰，且可以作为模板参数传递。

3.  **确保删除器处理`nullptr`：** 尽管通常在构造智能指针前会检查原始句柄是否有效，但在删除器内部添加`if (ptr)`检查仍然是一个良好的防御性编程习惯，以防万一。

4.  **考虑`std::make_unique`（如果适用）：** 虽然对于文件句柄这种通过C函数获取的资源，我们通常不能直接用`std::make_unique`，因为它不接受自定义删除器。但如果你的资源获取函数可以返回一个智能指针（比如你封装了一个`createFilePtr()`函数），那么`std::make_unique`是创建`unique_ptr`的推荐方式。对于文件句柄，我们通常是先`fopen`得到原始指针，再用原始指针和自定义删除器构造`unique_ptr`。

5.  **明确文件句柄的类型：** C标准库的`FILE*`、Windows API的`HANDLE`、Linux的`int`文件描述符，它们的关闭函数各不相同。确保你的删除器与你所管理的句柄类型相匹配。

通过遵循这些原则，我们不仅能利用智能指针的便利性，还能避免常见的陷阱，确保我们的文件操作代码既安全又高效。毕竟，代码的健壮性往往体现在那些“不起眼”的资源管理细节上。