C++ 智能指针与自定义删除器：管理非内存资源（文件句柄、网络连接）

C++ 智能指针与自定义删除器：让资源管理不再“糟心”

各位看官，大家好！今天咱们来聊聊C++里的智能指针，以及它们如何巧妙地配合自定义删除器，把那些让人头疼的资源管理问题给安排得明明白白。

想象一下，你是一位乐队指挥，手里握着各种乐器的控制权。内存就像乐队里的乐器，用完了要及时归还，不然就会“内存泄漏”，整个乐队的演奏就会变得越来越糟糕。而智能指针，就像你的助手，负责自动回收这些乐器，确保乐队演奏的流畅。

但是，乐队里不只有乐器啊！还有舞台灯光、音响设备，甚至乐队成员的伙食，这些也都是资源，用完了也得妥善处理。这些“非内存资源”该怎么办呢？别急，自定义删除器就是解决这个问题的秘密武器。

智能指针：告别手动 new 和 delete 的时代

在C++的世界里，内存管理一直是个让人头疼的问题。手动 new 了内存，就得记得 delete 掉，一不小心忘记了，就会造成内存泄漏。时间长了，程序就像一个漏气的气球，性能越来越差，最后直接崩溃。

智能指针的出现，就是为了解决这个问题。它们本质上是封装了原始指针的对象，利用RAII（Resource Acquisition Is Initialization，资源获取即初始化）的思想，在对象构造时获取资源，在对象析构时自动释放资源。

C++11 提供了三种智能指针：

• std::unique_ptr： 独占式拥有权。就像一把只能一把钥匙，只能有一个人拥有资源的所有权。unique_ptr 不能被复制，只能被移动。
• std::shared_ptr： 共享式拥有权。就像一把可以复制的钥匙，多个 shared_ptr 可以指向同一个资源，当最后一个 shared_ptr 销毁时，资源才会被释放。
• std::weak_ptr： 弱引用。它不拥有资源的所有权，只是观察 shared_ptr 指向的资源是否存在。可以用来解决 shared_ptr 循环引用的问题。

咱们先拿 unique_ptr 举个例子：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass created!" << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destroyed!" << std::endl;
    }
    void doSomething() {
        std::cout << "MyClass is doing something!" << std::endl;
    }
};

int main() {
    // 使用 unique_ptr 管理 MyClass 对象
    std::unique_ptr<MyClass> ptr(new MyClass());

    // 可以像普通指针一样使用
    ptr->doSomething();

    // 当 ptr 离开作用域时，MyClass 对象会自动被销毁
    return 0;
}

在这个例子中，我们使用 unique_ptr 管理 MyClass 对象。当 ptr 离开 main 函数的作用域时，unique_ptr 会自动调用 delete 运算符，释放 MyClass 对象占用的内存。这样，我们就不用手动 delete 内存了，避免了内存泄漏的风险。

自定义删除器：让智能指针管理非内存资源

智能指针很强大，但它默认使用 delete 运算符释放内存。如果我们要管理的不是内存，而是文件句柄、网络连接等非内存资源，该怎么办呢？

这时候，自定义删除器就派上用场了。自定义删除器是一个函数或函数对象，它定义了如何释放资源。我们可以将自定义删除器传递给智能指针，让智能指针在析构时调用自定义删除器，而不是默认的 delete 运算符。

举个例子，假设我们要管理一个文件句柄：

#include <iostream>
#include <memory>
#include <fstream>

// 自定义删除器，用于关闭文件句柄
struct FileDeleter {
    void operator()(std::ofstream* file) const {
        if (file) {
            file->close();
            std::cout << "File closed!" << std::endl;
            delete file;
        }
    }
};

int main() {
    // 使用 unique_ptr 和自定义删除器管理文件句柄
    std::unique_ptr<std::ofstream, FileDeleter> file(new std::ofstream("my_file.txt"), FileDeleter());

    if (file->is_open()) {
        *file << "Hello, world!" << std::endl;
    }

    // 当 file 离开作用域时，文件句柄会自动被关闭
    return 0;
}

在这个例子中，我们定义了一个名为 FileDeleter 的结构体，它重载了 operator() 运算符，实现了关闭文件句柄的逻辑。然后，我们将 FileDeleter 作为自定义删除器传递给 unique_ptr。当 file 离开 main 函数的作用域时，unique_ptr 会调用 FileDeleter 的 operator() 运算符，关闭文件句柄。

再来一个例子，假设我们要管理一个网络连接：

#include <iostream>
#include <memory>
#include <asio.hpp>

// 自定义删除器，用于关闭网络连接
struct SocketDeleter {
    void operator()(asio::ip::tcp::socket* socket) const {
        if (socket) {
            socket->close();
            std::cout << "Socket closed!" << std::endl;
            delete socket;
        }
    }
};

int main() {
    asio::io_context io_context;
    asio::ip::tcp::socket* raw_socket = new asio::ip::tcp::socket(io_context);

    // 使用 unique_ptr 和自定义删除器管理网络连接
    std::unique_ptr<asio::ip::tcp::socket, SocketDeleter> socket(raw_socket, SocketDeleter());

    // 连接到服务器 (这里仅作演示，实际需要处理异常)
    asio::error_code ec;
    socket->connect(asio::ip::tcp::endpoint(asio::ip::address::from_string("127.0.0.1"), 8080), ec);
    if (ec) {
        std::cerr << "Connect failed: " << ec.message() << std::endl;
        return 1;
    }

    // 发送数据 (这里仅作演示，实际需要处理异常)
    std::string message = "Hello, server!";
    asio::write(*socket, asio::buffer(message), ec);
    if (ec) {
        std::cerr << "Write failed: " << ec.message() << std::endl;
        return 1;
    }

    // 当 socket 离开作用域时，网络连接会自动被关闭
    return 0;
}

在这个例子中，我们定义了一个名为 SocketDeleter 的结构体，它重载了 operator() 运算符，实现了关闭网络连接的逻辑。然后，我们将 SocketDeleter 作为自定义删除器传递给 unique_ptr。当 socket 离开 main 函数的作用域时，unique_ptr 会调用 SocketDeleter 的 operator() 运算符，关闭网络连接。

Lambda 表达式：更简洁的自定义删除器

除了使用结构体，我们还可以使用 Lambda 表达式来定义自定义删除器。Lambda 表达式是一种匿名函数，可以方便地定义简单的函数对象。

#include <iostream>
#include <memory>
#include <fstream>

int main() {
    // 使用 unique_ptr 和 Lambda 表达式作为自定义删除器管理文件句柄
    std::unique_ptr<std::ofstream, void (*)(std::ofstream*)> file(
        new std::ofstream("my_file.txt"),
        [](std::ofstream* f) {
            if (f) {
                f->close();
                std::cout << "File closed (Lambda)!" << std::endl;
                delete f;
            }
        }
    );

    if (file->is_open()) {
        *file << "Hello, world! (Lambda)" << std::endl;
    }

    // 当 file 离开作用域时，文件句柄会自动被关闭
    return 0;
}

在这个例子中，我们使用 Lambda 表达式定义了一个匿名函数，实现了关闭文件句柄的逻辑。然后，我们将这个 Lambda 表达式作为自定义删除器传递给 unique_ptr。

使用 Lambda 表达式可以使代码更简洁，尤其是在自定义删除器的逻辑比较简单的情况下。

shared_ptr 与自定义删除器：共享资源的管理

shared_ptr 也可以使用自定义删除器，用于管理共享的非内存资源。当最后一个 shared_ptr 销毁时，自定义删除器会被调用，释放资源。

#include <iostream>
#include <memory>
#include <fstream>

int main() {
    // 使用 shared_ptr 和 Lambda 表达式作为自定义删除器管理文件句柄
    std::shared_ptr<std::ofstream> file(
        new std::ofstream("my_file.txt"),
        [](std::ofstream* f) {
            if (f) {
                f->close();
                std::cout << "File closed (shared_ptr + Lambda)!" << std::endl;
                delete f;
            }
        }
    );

    if (file->is_open()) {
        *file << "Hello, world! (shared_ptr + Lambda)" << std::endl;
    }

    // 创建另一个 shared_ptr 指向同一个文件句柄
    std::shared_ptr<std::ofstream> file2 = file;

    // 当 file 和 file2 都离开作用域时，文件句柄会被关闭一次
    return 0;
}

在这个例子中，我们创建了两个 shared_ptr 对象，它们都指向同一个文件句柄。当 file 和 file2 都离开 main 函数的作用域时，自定义删除器会被调用一次，关闭文件句柄。

总结：让资源管理不再“糟心”

智能指针和自定义删除器是 C++ 中强大的资源管理工具。它们可以帮助我们自动释放内存和非内存资源，避免内存泄漏和资源泄露的风险。

通过使用智能指针和自定义删除器，我们可以让代码更加健壮、可靠，也让我们的编程工作更加轻松愉快。

所以，下次当你需要管理资源时，不妨考虑一下智能指针和自定义删除器，让它们来帮你解决“糟心”的资源管理问题吧！它们就像你的得力助手，让你的代码更加优雅、安全。

希望这篇文章能帮助你更好地理解 C++ 中的智能指针和自定义删除器。记住，良好的资源管理是编写高质量 C++ 代码的关键。祝你编程愉快！