如何利用智能指针管理非内存资源（如文件句柄、网络套接字）？

各位C++开发者，欢迎来到今天的专题讲座。我们今天要探讨的核心议题是：如何利用C++智能指针，高效、安全地管理那些并非内存的宝贵系统资源？

在C++编程中，内存管理一直是核心挑战之一。然而，现实世界的应用远不止于内存。文件句柄、网络套接字、数据库连接、互斥锁、图形上下文，这些都是我们日常开发中频繁接触的“非内存资源”。它们有一个共同的特性：需要在使用后被正确地释放或关闭。如果忘记释放，就会导致资源泄漏，轻则影响性能，重则导致系统崩溃。

传统的C风格资源管理依赖于手动调用close()、fclose()、delete[]等函数，这极易出错。尤其是在复杂的代码路径、异常处理和多线程环境中，确保每个资源都在正确的时间点被释放，简直是一场噩梦。幸运的是，C++为我们提供了强大的工具——资源获取即初始化（Resource Acquisition Is Initialization, RAII）原则，而智能指针正是RAII原则在实践中的典范。

本讲座将深入剖析智能指针的机制，并演示如何通过定制其行为，将其威力拓展到非内存资源的管理领域。

---

一、 传统资源管理的困境：手动模式的脆弱性

在深入智能指针之前，我们首先回顾一下手动管理资源的典型问题。考虑一个简单的文件操作：

#include <cstdio> // For FILE, fopen, fclose
#include <iostream>
#include <string>

void processFile_manual(const std::string& filename) {
    FILE* file = nullptr;
    try {
        file = fopen(filename.c_str(), "r");
        if (!file) {
            throw std::runtime_error("Failed to open file: " + filename);
        }

        char buffer[256];
        if (fgets(buffer, sizeof(buffer), file) != nullptr) {
            std::cout << "First line: " << buffer << std::endl;
        } else {
            // 即使这里发生错误，也必须确保文件被关闭
            std::cerr << "Failed to read from file or file is empty." << std::endl;
        }

        // 假设这里有更多操作，可能抛出异常

        fclose(file); // 资源释放点 1
        file = nullptr; // 避免悬空指针
    } catch (const std::exception& e) {
        std::cerr << "Error processing file: " << e.what() << std::endl;
        if (file) {
            fclose(file); // 资源释放点 2 (异常路径)
            file = nullptr;
        }
    }
    // 如果没有任何异常，或者异常被捕获，并且file不为nullptr，文件都会被关闭
    // 但如果 fopen 失败，file 就是 nullptr，不能调用 fclose
    // 如果 fgets 失败，且后面有异常，也必须确保关闭
}

// 另一个例子：网络套接字
#ifdef _WIN32
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
#else
#include <sys/socket.h>
#include <unistd.h> // for close
#include <arpa/inet.h> // for inet_addr
#endif

void cleanup_socket(int sock) {
#ifdef _WIN32
    closesocket(sock);
#else
    close(sock);
#endif
}

void connectToServer_manual(const std::string& ip, int port) {
#ifdef _WIN32
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "WSAStartup failed." << std::endl;
        return;
    }
#endif

    int clientSocket = -1; // 使用-1作为无效套接字标识
    try {
        clientSocket = socket(AF_INET, SOCK_STREAM, 0);
        if (clientSocket == -1) {
            throw std::runtime_error("Failed to create socket.");
        }

        sockaddr_in serverAddr{};
        serverAddr.sin_family = AF_INET;
        serverAddr.sin_port = htons(port);
#ifdef _WIN32
        serverAddr.sin_addr.s_addr = inet_addr(ip.c_str());
#else
        inet_pton(AF_INET, ip.c_str(), &serverAddr.sin_addr);
#endif

        if (connect(clientSocket, (sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
            throw std::runtime_error("Failed to connect to server.");
        }

        std::string message = "Hello from client!";
        send(clientSocket, message.c_str(), message.length(), 0);
        std::cout << "Sent: " << message << std::endl;

        char buffer[256];
        int bytesReceived = recv(clientSocket, buffer, sizeof(buffer) - 1, 0);
        if (bytesReceived > 0) {
            buffer[bytesReceived] = '';
            std::cout << "Received: " << buffer << std::endl;
        } else if (bytesReceived == 0) {
            std::cout << "Server closed connection." << std::endl;
        } else {
            std::cerr << "Failed to receive data." << std::endl;
        }

        cleanup_socket(clientSocket); // 资源释放点 1
        clientSocket = -1;
    } catch (const std::exception& e) {
        std::cerr << "Error connecting to server: " << e.what() << std::endl;
        if (clientSocket != -1) {
            cleanup_socket(clientSocket); // 资源释放点 2 (异常路径)
            clientSocket = -1;
        }
    }

#ifdef _WIN32
    WSACleanup();
#endif
}

从上述两个例子中，我们可以清晰地看到手动管理资源的痛点：

1. 重复代码： 在正常执行路径和异常路径中，都需要编写资源释放的代码。
2. 遗漏释放： 任何一个return语句、异常抛出，或者复杂的控制流都可能导致fclose或cleanup_socket被跳过。
3. 调试困难： 资源泄漏问题往往难以追踪，可能在程序运行一段时间后才显现。
4. 不符合直觉： 程序员需要时刻记住资源的生命周期，这增加了认知负担。

---

二、 RAII 原则：C++ 资源管理的基石

为了解决手动管理资源的这些问题，C++引入了RAII（Resource Acquisition Is Initialization）原则。RAII的核心思想是：

• 资源获取与对象生命周期绑定： 当一个对象被创建时（初始化阶段），它负责获取（或称“拥有”）一个资源。
• 资源释放与对象销毁绑定： 当该对象超出其作用域被销毁时（析构阶段），它的析构函数会自动释放所拥有的资源。

因为C++保证了局部对象在超出作用域时一定会调用析构函数（无论是正常退出还是异常抛出），所以RAII为我们提供了一种异常安全且确定性的资源管理机制。

智能指针正是RAII原则的完美体现。它们是包装了原始指针的类，在构造时获取资源（通常是内存），在析构时自动释放资源。但它们的强大之处远不止于此，通过自定义删除器（Custom Deleter），它们可以管理任何类型的资源。

---

三、 智能指针概述与选择

C++11引入了三种标准智能指针：

• std::unique_ptr：独占所有权。资源只能由一个unique_ptr持有。当unique_ptr被销毁时，它所拥有的资源也会被销毁。它是轻量级的，没有额外的运行时开销（除了存储删除器）。
• std::shared_ptr：共享所有权。多个shared_ptr可以共同拥有同一个资源。资源只有当最后一个shared_ptr被销毁时才会被释放。它通过引用计数实现，因此会带来一定的运行时开销。
• std::weak_ptr：弱引用。它不拥有资源，只是观察shared_ptr所管理的资源。它不会增加引用计数，主要用于解决shared_ptr可能导致的循环引用问题。

对于管理非内存资源，我们的首选通常是std::unique_ptr，因为它代表了明确的、独占的资源所有权，并且性能开销最小。只有在确实需要共享资源所有权时，才会考虑std::shared_ptr。std::weak_ptr在此场景下更多是作为shared_ptr的辅助工具，而非直接管理资源本身。

---

四、 std::unique_ptr 与自定义删除器管理非内存资源

std::unique_ptr的模板定义如下：

template<class T, class Deleter = std::default_delete<T>>
class unique_ptr;

这里的关键是第二个模板参数Deleter。默认情况下，它使用std::default_delete<T>，该删除器会简单地调用delete来释放T*指向的内存。然而，我们可以提供自定义的Deleter类型，来执行任何我们需要的资源释放操作。

自定义删除器可以是：

1. 函数对象（Functor）或Lambda表达式： 推荐方式，尤其是对于无状态的删除器。
2. 函数指针： 适用于C风格的回调函数。

4.1 示例一：管理文件句柄 (FILE*)

我们将使用std::unique_ptr来封装FILE*，并提供一个自定义删除器，使其在析构时调用fclose()。

方法一：使用函数对象（Struct）作为删除器

#include <cstdio>
#include <iostream>
#include <memory> // For std::unique_ptr
#include <string>
#include <stdexcept> // For std::runtime_error

// 1. 定义一个自定义删除器结构体
struct FileCloser {
    void operator()(FILE* file) const {
        if (file) {
            // 注意：fclose 可能失败，但在析构函数中抛出异常是不安全的行为
            // 通常的做法是记录错误或忽略
            if (fclose(file) != 0) {
                std::cerr << "Error closing file!" << std::endl;
                // 在实际应用中，这里可能需要更复杂的错误处理或日志记录
            }
        }
    }
};

void processFile_smart(const std::string& filename) {
    // 2. 使用 unique_ptr 结合自定义删除器
    // unique_ptr<资源类型, 删除器类型>
    std::unique_ptr<FILE, FileCloser> filePtr(fopen(filename.c_str(), "r"));

    if (!filePtr) { // 检查文件是否成功打开
        throw std::runtime_error("Failed to open file: " + filename);
    }

    char buffer[256];
    if (fgets(buffer, sizeof(buffer), filePtr.get()) != nullptr) { // 使用 .get() 获取原始指针
        std::cout << "First line: " << buffer << std::endl;
    } else {
        std::cerr << "Failed to read from file or file is empty." << std::endl;
    }

    // 假设这里有更多操作，可能抛出异常

    // 无需手动调用 fclose(filePtr.get())
    // filePtr 超出作用域时，FileCloser::operator() 会被自动调用
}

// 主函数调用示例
int main_file_example() {
    // 创建一个临时文件用于测试
    FILE* testFile = fopen("test.txt", "w");
    if (testFile) {
        fprintf(testFile, "This is the first line.n");
        fprintf(testFile, "This is the second line.n");
        fclose(testFile);
    }

    try {
        processFile_smart("test.txt");
        processFile_smart("non_existent_file.txt"); // 演示异常处理
    } catch (const std::exception& e) {
        std::cerr << "Caught exception in main: " << e.what() << std::endl;
    }

    // 文件句柄在这里被自动关闭
    std::cout << "File processing finished." << std::endl;

    return 0;
}

方法二：使用Lambda表达式作为删除器（C++11及更高版本）

Lambda表达式是实现自定义删除器更简洁的方式，尤其适用于删除器逻辑简单且不需要在多处复用的情况。

#include <cstdio>
#include <iostream>
#include <memory>
#include <string>
#include <stdexcept>

void processFile_smart_lambda(const std::string& filename) {
    // 1. 定义一个lambda表达式作为删除器
    // 注意：lambda必须是无状态的（即不捕获任何外部变量），否则 unique_ptr 的大小会增加
    // 对于有状态的删除器，unique_ptr 的类型需要包含 lambda 的类型，通常用 std::function 或 decltype
    auto file_deleter = [](FILE* file) {
        if (file) {
            if (fclose(file) != 0) {
                std::cerr << "Error closing file with lambda deleter!" << std::endl;
            }
        }
    };

    // 2. 使用 unique_ptr 结合 lambda 删除器
    // unique_ptr 的第二个模板参数是 lambda 的类型，可以使用 decltype
    std::unique_ptr<FILE, decltype(file_deleter)> filePtr(fopen(filename.c_str(), "r"), file_deleter);

    if (!filePtr) {
        throw std::runtime_error("Failed to open file: " + filename);
    }

    char buffer[256];
    if (fgets(buffer, sizeof(buffer), filePtr.get()) != nullptr) {
        std::cout << "First line (lambda): " << buffer << std::endl;
    } else {
        std::cerr << "Failed to read from file or file is empty (lambda)." << std::endl;
    }
}

// 主函数调用示例
int main_file_lambda_example() {
    FILE* testFile = fopen("test_lambda.txt", "w");
    if (testFile) {
        fprintf(testFile, "Lambda's first line.n");
        fclose(testFile);
    }

    try {
        processFile_smart_lambda("test_lambda.txt");
    } catch (const std::exception& e) {
        std::cerr << "Caught exception in main (lambda): " << e.what() << std::endl;
    }
    std::cout << "File processing finished (lambda)." << std::endl;
    return 0;
}

关键点：

• std::unique_ptr的构造函数接受一个原始指针和一个删除器对象。
• filePtr.get()用于获取原始的FILE*指针，以便传递给C标准库函数。
• 当filePtr超出作用域时（无论是正常退出函数还是抛出异常），它的析构函数会自动调用提供的删除器，从而安全地关闭文件。
• 对于无状态的函数对象或lambda，std::unique_ptr的开销与原始指针相同。

4.2 示例二：管理网络套接字 (int 或 SOCKET)

网络套接字是另一种典型的非内存资源。在Linux/Unix系统中，套接字通常表示为一个整数文件描述符；在Windows系统中，则是一个SOCKET类型（实际上是UINT_PTR）。

#include <iostream>
#include <memory>
#include <string>
#include <stdexcept>

// 平台相关的套接字头文件和函数
#ifdef _WIN32
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib") // Link with ws2_32.lib
typedef SOCKET SocketHandle;
#define INVALID_SOCKET_VALUE INVALID_SOCKET
#define close_socket(s) closesocket(s)
#else
#include <sys/socket.h>
#include <unistd.h> // For close
#include <arpa/inet.h> // For inet_pton
#include <netinet/in.h> // For sockaddr_in
typedef int SocketHandle;
#define INVALID_SOCKET_VALUE -1
#define close_socket(s) close(s)
#endif

// 1. 定义一个自定义删除器结构体
struct SocketCloser {
    void operator()(SocketHandle sock) const {
        if (sock != INVALID_SOCKET_VALUE) {
            std::cout << "Closing socket: " << sock << std::endl;
            if (close_socket(sock) != 0) {
                std::cerr << "Error closing socket!" << std::endl;
                // 同样，析构函数中不宜抛出异常
            }
        }
    }
};

void connectToServer_smart(const std::string& ip, int port) {
#ifdef _WIN32
    // Windows Sockets API 必须先初始化
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        throw std::runtime_error("WSAStartup failed.");
    }
    // 使用 RAII 确保 WSACleanup 被调用
    std::unique_ptr<WSADATA, decltype([](WSADATA*){ WSACleanup(); })> wsaGuard(&wsaData);
#endif

    // 2. 使用 unique_ptr 结合自定义删除器来管理套接字句柄
    std::unique_ptr<SocketHandle, SocketCloser> clientSocketPtr(
        socket(AF_INET, SOCK_STREAM, 0)
    );

    if (*clientSocketPtr == INVALID_SOCKET_VALUE) { // 解引用 unique_ptr 获取底层值
        throw std::runtime_error("Failed to create socket.");
    }

    sockaddr_in serverAddr{};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(port);
#ifdef _WIN32
    serverAddr.sin_addr.s_addr = inet_addr(ip.c_str());
    if (serverAddr.sin_addr.s_addr == INADDR_NONE) {
        throw std::runtime_error("Invalid IP address format.");
    }
#else
    if (inet_pton(AF_INET, ip.c_str(), &serverAddr.sin_addr) <= 0) {
        throw std::runtime_error("Invalid IP address format.");
    }
#endif

    if (connect(*clientSocketPtr, (sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
        throw std::runtime_error("Failed to connect to server.");
    }

    std::string message = "Hello from smart client!";
    send(*clientSocketPtr, message.c_str(), message.length(), 0);
    std::cout << "Sent: " << message << std::endl;

    char buffer[256];
    int bytesReceived = recv(*clientSocketPtr, buffer, sizeof(buffer) - 1, 0);
    if (bytesReceived > 0) {
        buffer[bytesReceived] = '';
        std::cout << "Received: " << buffer << std::endl;
    } else if (bytesReceived == 0) {
        std::cout << "Server closed connection." << std::endl;
    } else {
        std::cerr << "Failed to receive data." << std::endl;
    }

    // 离开作用域时，clientSocketPtr 会自动关闭套接字
    std::cout << "Socket operations completed." << std::endl;
}

// 主函数调用示例
int main_socket_example() {
    // 启动一个简单的服务器（例如 nc -l 12345）来测试
    // 或者连接到已知的服务，如 HTTP 端口 80 (但不建议直接发纯文本)
    try {
        // 尝试连接一个不存在的服务器或端口来测试异常
        // connectToServer_smart("127.0.0.1", 12346);
        // 假设有一个服务器在 12345 端口监听
        connectToServer_smart("127.0.0.1", 12345);
    } catch (const std::exception& e) {
        std::cerr << "Caught exception in main (socket): " << e.what() << std::endl;
    }
    std::cout << "Socket example finished." << std::endl;
    return 0;
}

关键点：

• 我们定义了一个SocketCloser结构体，并在其operator()中调用平台特定的套接字关闭函数。
• std::unique_ptr<SocketHandle, SocketCloser>被用来管理套接字。
• 通过解引用*clientSocketPtr，可以直接像使用原始套接字句柄一样操作它。

4.3 示例三：管理互斥锁 (pthread_mutex_t)

除了文件和网络，同步原语也是常见的非内存资源。例如，pthread_mutex_t需要pthread_mutex_init和pthread_mutex_destroy。

#include <iostream>
#include <memory>
#include <string>
#include <stdexcept>
#include <pthread.h> // For pthread_mutex_t

// 1. 定义一个自定义删除器结构体
struct MutexDestroyer {
    void operator()(pthread_mutex_t* mutex) const {
        if (mutex) {
            std::cout << "Destroying pthread_mutex_t at " << mutex << std::endl;
            if (pthread_mutex_destroy(mutex) != 0) {
                std::cerr << "Error destroying mutex!" << std::endl;
            }
            delete mutex; // 如果 mutex 是通过 new 分配的，则需要 delete
        }
    }
};

void useMutex_smart() {
    // 2. 创建一个动态分配的 pthread_mutex_t
    pthread_mutex_t* raw_mutex = new pthread_mutex_t;
    if (pthread_mutex_init(raw_mutex, nullptr) != 0) {
        delete raw_mutex; // 初始化失败，需要手动释放
        throw std::runtime_error("Failed to initialize mutex.");
    }

    // 3. 使用 unique_ptr 结合自定义删除器
    std::unique_ptr<pthread_mutex_t, MutexDestroyer> mutexPtr(raw_mutex);

    std::cout << "Acquiring mutex..." << std::endl;
    pthread_mutex_lock(mutexPtr.get()); // 锁定互斥量
    std::cout << "Mutex acquired. Doing some work..." << std::endl;
    // 假设这里有一些需要保护的代码
    std::string protected_data = "Shared data";
    std::cout << "Protected data: " << protected_data << std::endl;
    std::cout << "Releasing mutex..." << std::endl;
    pthread_mutex_unlock(mutexPtr.get()); // 解锁互斥量
    std::cout << "Mutex released." << std::endl;

    // 离开作用域时，mutexPtr 会自动调用 MutexDestroyer，释放并销毁互斥量
}

// 主函数调用示例
int main_mutex_example() {
    try {
        useMutex_smart();
        useMutex_smart(); // 再次调用，演示独立资源管理
    } catch (const std::exception& e) {
        std::cerr << "Caught exception in main (mutex): " << e.what() << std::endl;
    }
    std::cout << "Mutex example finished." << std::endl;
    return 0;
}

注意： 对于互斥锁，更常见的RAII封装是std::lock_guard或std::unique_lock，它们管理的是锁的获取和释放（lock()和unlock()），而不是互斥锁对象本身的生命周期。这里的示例是关于互斥锁对象本身的创建和销毁。

---

五、 std::shared_ptr 与自定义删除器管理非内存资源

当多个对象或代码块需要共享对某个资源的访问，并且希望资源在所有使用者都完成后才释放时，std::shared_ptr就派上用场了。它通过引用计数（reference count）来跟踪有多少个shared_ptr实例指向同一个资源。

std::shared_ptr的构造函数同样可以接受一个自定义删除器：

template<class Y, class Deleter>
shared_ptr(Y* p, Deleter d);

5.1 示例：共享数据库连接

假设我们有一个昂贵的数据库连接，我们希望多个服务或线程能够共享它，并且只有当所有这些使用者都断开连接后，数据库连接才真正关闭。

#include <iostream>
#include <memory>
#include <string>
#include <stdexcept>
#include <vector>
#include <thread> // For std::thread

// 模拟数据库连接句柄
struct DBConnection {
    std::string id;
    bool is_open;

    DBConnection(const std::string& conn_id) : id(conn_id), is_open(true) {
        std::cout << "DBConnection [" << id << "] opened." << std::endl;
    }

    void query(const std::string& sql) {
        if (!is_open) {
            std::cerr << "Error: DBConnection [" << id << "] is closed!" << std::endl;
            return;
        }
        std::cout << "DBConnection [" << id << "] executing query: " << sql << std::endl;
        // 模拟查询操作
    }

    // 不提供析构函数，由自定义删除器负责关闭
};

// 1. 定义自定义删除器
struct DBConnectionCloser {
    void operator()(DBConnection* conn) const {
        if (conn) {
            std::cout << "DBConnection [" << conn->id << "] closing..." << std::endl;
            // 模拟关闭操作
            conn->is_open = false;
            delete conn; // 释放 DBConnection 对象本身的内存
        }
    }
};

// 模拟一个使用数据库连接的服务
void databaseService(std::shared_ptr<DBConnection> connection) {
    std::cout << "Service started with connection [" << connection->id << "]." << std::endl;
    connection->query("SELECT * FROM Users;");
    std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 模拟工作
    std::cout << "Service finished with connection [" << connection->id << "]." << std::endl;
}

int main_db_example() {
    std::cout << "Starting DB example..." << std::endl;

    // 2. 创建一个 shared_ptr 管理 DBConnection，并指定自定义删除器
    // DBConnection 需要动态分配，因为 shared_ptr 负责 delete
    std::shared_ptr<DBConnection> primary_conn;
    try {
        primary_conn = std::shared_ptr<DBConnection>(
            new DBConnection("MainDB"), DBConnectionCloser()
        );
    } catch (const std::bad_alloc& e) {
        std::cerr << "Failed to allocate DBConnection: " << e.what() << std::endl;
        return 1;
    }

    std::cout << "Primary connection ref count: " << primary_conn.use_count() << std::endl;

    // 3. 多个 shared_ptr 共享同一个连接
    std::vector<std::thread> threads;
    for (int i = 0; i < 3; ++i) {
        // 每次传递 primary_conn，都会创建一个新的 shared_ptr 副本，增加引用计数
        threads.emplace_back(databaseService, primary_conn);
    }

    primary_conn->query("INSERT INTO Logs VALUES ('App started');");
    std::cout << "Primary connection ref count: " << primary_conn.use_count() << std::endl;

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "All services finished." << std::endl;
    std::cout << "Primary connection ref count: " << primary_conn.use_count() << std::endl;

    // primary_conn 离开作用域时，引用计数变为 0，DBConnectionCloser 会被调用
    std::cout << "Exiting main_db_example(). DB connection will close now." << std::endl;
    return 0;
}

关键点：

• std::shared_ptr的引用计数机制确保了资源只有在最后一个shared_ptr实例被销毁时才释放。
• DBConnectionCloser负责关闭连接并释放DBConnection对象本身的内存。
• std::shared_ptr的内存开销比std::unique_ptr大，因为它需要维护引用计数（通常在堆上额外分配一个控制块）。

---

六、 自定义删除器的类型与性能考量

在选择自定义删除器时，我们有多种实现方式，它们在性能和代码简洁性上有所不同。

删除器类型	优点	缺点	unique_ptr 大小	shared_ptr 影响
函数指针	C风格兼容，易于理解	不支持有状态删除器，类型签名必须完全匹配	sizeof(T*)	略微增加控制块大小
无状态函数对象	类型安全，可用于模板，零运行时开销	需要额外定义结构体或类	sizeof(T*)	略微增加控制块大小
无状态Lambda	简洁，内联，零运行时开销	类型需使用decltype，不适用于复杂逻辑	sizeof(T*)	略微增加控制块大小
有状态函数对象	可存储上下文数据（如日志句柄、错误码）	unique_ptr大小增加（存储状态），shared_ptr控制块增加	sizeof(T*) + sizeof(State)	略微增加控制块大小
有状态Lambda	简洁，可捕获上下文数据	unique_ptr大小增加（存储捕获），shared_ptr控制块增加	sizeof(T*) + sizeof(Captures)	略微增加控制块大小

性能考量：

• std::unique_ptr： 对于无状态的自定义删除器（函数指针、无捕获的lambda、无成员的函数对象），std::unique_ptr的大小与原始指针完全相同，并且删除器的调用通常可以被编译器内联，实现零运行时开销。如果删除器是有状态的，unique_ptr会将其状态存储在内部，从而增加其大小。
• std::shared_ptr： 无论删除器是否自定义、是否有状态，std::shared_ptr都会在堆上分配一个控制块来存储引用计数和删除器。因此，它总是比std::unique_ptr有更大的内存开销和一定的运行时开销（维护引用计数）。自定义删除器会存储在控制块中。

最佳实践：

• 优先使用无状态的Lambda或函数对象，因为它们提供了最佳的性能和简洁性。
• 如果删除器需要访问一些运行时数据（例如一个日志记录器），可以考虑使用有状态的函数对象或Lambda，但要意识到这会增加unique_ptr的大小。
• 避免在删除器中抛出异常：析构函数中抛出异常会导致未定义行为，可能导致程序终止。如果删除资源时发生错误，应记录错误并优雅地失败，而不是抛出异常。

---

七、 深入理解 std::unique_ptr 的 get(), release(), reset()

智能指针不仅仅是自动管理资源，它们还提供了一些方法来与底层原始资源进行交互。

• T* get() const noexcept;：返回智能指针当前持有的原始指针。这是一个非常常用的方法，当需要将原始指针传递给不接受智能指针的C API时，可以使用它。
  • 警告： 不要通过get()返回的原始指针来delete资源，因为智能指针仍然拥有它，会在析构时再次尝试delete，导致双重释放。
• pointer release() noexcept;：放弃智能指针对资源的拥有权，并返回原始指针。智能指针将不再管理该资源（即其内部指针被设置为nullptr），因此不会在析构时释放它。
  • 用途： 当你需要将资源的拥有权转移给另一个不使用智能指针的系统时，或者需要将资源转移到一个不同的智能指针类型时。调用release()后，你必须手动管理返回的原始指针，否则会导致资源泄漏。
• void reset(pointer p = pointer()) noexcept;：释放智能指针当前拥有的资源，并（可选地）使其拥有新的资源p。
  • 用途： 替换智能指针管理的资源。如果p是nullptr，则智能指针只是释放当前资源并变为空。

#include <iostream>
#include <memory>
#include <cstdio> // For FILE, fopen, fclose

struct FileCloser {
    void operator()(FILE* file) const {
        if (file) {
            std::cout << "Custom deleter closing file: " << file << std::endl;
            fclose(file);
        }
    }
};

void demonstrateUniquePtrMethods() {
    std::cout << "--- Demonstrating unique_ptr methods ---" << std::endl;

    std::unique_ptr<FILE, FileCloser> file1(fopen("test_file1.txt", "w"));
    if (!file1) { std::cerr << "Failed to open test_file1.txt" << std::endl; return; }
    fprintf(file1.get(), "Hello from file1n");
    std::cout << "file1 raw pointer: " << file1.get() << std::endl;

    // get(): 获取原始指针
    FILE* rawFile = file1.get();
    // 可以在这里使用 rawFile 传递给 C API，但不要 delete 它

    // release(): 放弃所有权，返回原始指针
    std::cout << "Releasing file1's ownership..." << std::endl;
    FILE* orphanedFile = file1.release(); // file1 变为 nullptr，不再管理该文件
    std::cout << "file1 after release: " << file1.get() << std::endl;
    // orphanedFile 现在是原始指针，必须手动关闭！
    if (orphanedFile) {
        std::cout << "Manually closing orphaned file: " << orphanedFile << std::endl;
        fclose(orphanedFile);
    }

    // reset(): 释放当前资源并管理新资源
    std::unique_ptr<FILE, FileCloser> file2(fopen("test_file2.txt", "w"));
    if (!file2) { std::cerr << "Failed to open test_file2.txt" << std::endl; return; }
    fprintf(file2.get(), "Hello from file2n");
    std::cout << "file2 raw pointer: " << file2.get() << std::endl;

    std::cout << "Resetting file2 to manage test_file3.txt..." << std::endl;
    FILE* newRawFile = fopen("test_file3.txt", "w");
    if (!newRawFile) { std::cerr << "Failed to open test_file3.txt" << std::endl; return; }
    file2.reset(newRawFile); // 原来的 test_file2.txt 会被自动关闭
    fprintf(file2.get(), "Hello from file3n");
    std::cout << "file2 after reset: " << file2.get() << std::endl;

    // reset() to nullptr: 释放当前资源并变为空
    std::cout << "Resetting file2 to nullptr..." << std::endl;
    file2.reset(); // test_file3.txt 会被自动关闭
    std::cout << "file2 after reset(nullptr): " << file2.get() << std::endl;

    std::cout << "--- End of unique_ptr methods demonstration ---" << std::endl;
}

int main_methods_example() {
    demonstrateUniquePtrMethods();
    return 0;
}

---

八、 智能指针在非内存资源管理中的优势

结合RAII和智能指针管理非内存资源，带来了诸多显著优势：

1. 异常安全： 无论函数如何退出（正常返回、抛出异常），资源都保证会被释放。这消除了在catch块和正常返回路径中重复编写资源清理代码的需要。
2. 代码简洁： 大幅减少了手动close()、free()等调用，使代码更清晰，更专注于业务逻辑。
3. 避免资源泄漏： 自动化管理机制极大地降低了资源泄漏的风险。
4. 所有权语义清晰： unique_ptr明确表示独占所有权，shared_ptr表示共享所有权，这有助于设计和理解代码。
5. 易于维护： 随着代码库的增长和复杂化，手动资源管理变得越来越难以维护。智能指针提供了一个统一且可靠的模式。
6. 可组合性： 智能指针可以很容易地集成到其他RAII类中，构建更高级的资源管理抽象。

---

九、 总结与展望

通过本讲座，我们深入探讨了如何利用C++智能指针，特别是std::unique_ptr和std::shared_ptr，结合自定义删除器来高效、安全地管理各种非内存资源。从文件句柄到网络套接字，再到互斥锁，智能指针将RAII原则的强大力量从内存管理拓展到了更广阔的系统资源领域。

这种模式不仅使得代码更加健壮、异常安全，而且极大地简化了资源管理逻辑，提升了开发效率和代码的可维护性。作为一名专业的C++开发者，熟练掌握智能指针及其自定义删除器的用法，是编写高质量、高可靠性C++应用程序不可或缺的技能。

在未来的C++标准中，我们可能会看到更多对RAII和资源管理的语言级支持，但智能指针和自定义删除器模式将继续作为C++生态系统的核心组成部分，为我们处理复杂资源管理挑战提供坚实的基础。实践出真知，鼓励大家在自己的项目中积极采纳和探索这些技术。