我们什么时候应该在 unique_ptr 中使用自定义删除器而不是默认删除器？

Question

我无法理解，如果unique_ptr中已经有默认删除器，那么使用自定义删除器有什么用呢？

任何人都可以通过举一个简单的例子来解释这一点吗？

Answer 1

下面是使用std::unique_ptr以RAII样式管理旧的 C 样式FILE*的示例。

当std::unique_ptr尝试释放托管资源时，删除器将自动关闭文件。

这很有用，例如，如果您有一些使用FILE*文件的遗留代码并且您希望避免手动管理关闭它们。

#include <iostream>
#include <memory>

struct FileDeleter
{
    void operator()(FILE* pFile)
    {
        if (pFile)
        {
            std::cout << "closing file ...\n";
            fclose(pFile);
        }
    }
};

using FileUniquePtr = std::unique_ptr<FILE, FileDeleter>;

int main()
{
    {
        // Getting a FILE* from legacy code:
        FILE* pFile = nullptr;
        std::cout << "opening file ...\n";
        auto err = fopen_s(&pFile, "aaa.txt", "r");
        if (err != 0)
        {
            // Handle error ...
            return -1;
        }
        
        // New C++ code:
        FileUniquePtr filePtr{ pFile };
        // Do something with the file via filePtr ...

    } // Here filePtr goes out of scope and the deleter will be called and close the file automatically.
}

Output：

opening file ...
closing file ...

Answer 2

我使用自定义删除来快速包装 C-API，例如帮助我处理 OpenSSL：

namespace helper {
template<typename T>
struct Deleter;

template<>
struct Deleter<::BIO>
{
    void operator()(::BIO* p) const
    {
        // result used during debugging
        [[maybe_unused]] auto result = BIO_free(p);
    }
};

template<>
struct Deleter<::X509>
{
    void operator()(::X509* p) const
    {
        X509_free(p);
    }
};

template<>
struct Deleter<::PKCS12>
{
    void operator()(::PKCS12* p) const
    {
        PKCS12_free(p);
    }
};

template<>
struct Deleter<::EVP_PKEY>
{
    void operator()(::EVP_PKEY* p) const
    {
        EVP_PKEY_free(p);
    }
};

template<>
struct Deleter<STACK_OF(X509)>
{
    void operator()(STACK_OF(X509) * p) const
    {
        sk_X509_pop_free(p, X509_free);
    }
};

template<>
struct Deleter<STACK_OF(GENERAL_NAME)>
{
    void operator()(STACK_OF(GENERAL_NAME) * p) const
    {
        sk_GENERAL_NAME_free(p);
    }
};

template<>
struct Deleter<GENERAL_NAME>
{
    void operator()(GENERAL_NAME* p) const
    {
        GENERAL_NAME_free(p);
    }
};

template<typename T, typename D = Deleter<T>>
std::unique_ptr<T, D> wrapUnique(T* p, D deleter = {})
{
    return std::unique_ptr<T, D>{p, deleter};
}
}

我使用其他辅助函数来使用 OpenSSL 更多 C++sy。 这在处理错误时特别方便（因为在这种情况下释放资源是无痛的）。

Answer 3

如果对unique_ptr包裹的指针进行delete是处理它的正确做法，则默认删除器是可以的。 如果您的指针来自new ，那没关系，但在许多其他情况下这是不正确的。

一个简单的例子是FILE * ：一个FILE *是一个不能用delete的指针，但是你必须在它上面使用fclose 。 使用自定义删除器很容易将其包装在unique_ptr中并让它处理销毁/移动/...：

namespace detail {
    struct file_ptr_deleter {
        void operator() (FILE *fp) {
            if(fp) fclose(fp);
        }
    };
}

/// RAII-style wrapper for a FILE*
struct unique_c_file : std::unique_ptr<FILE, detail::file_ptr_deleter> {
    using std::unique_ptr<FILE, detail::file_ptr_deleter>::unique_ptr;
    operator FILE *() { return get(); }
};

（在这种情况下，我什至继承自std::unique_ptr以简化unique_c_file直接在 C API 中的使用）。

其他可能更常见的情况是，如果您有来自图书馆的 memory，图书馆会提供自己的 function 来删除它； 例如，您可以使用 BSD sockets，其中getaddrinfo为您提供了一个必须使用freeaddrinfo释放的addrinfo * ； 即使在这种情况下，也很容易为此创建一个智能指针：

namespace detail {
    struct addrinfo_deleter {
        void operator()(addrinfo *elem) {
            if(elem) freeaddrinfo(elem);
        }
    };
}

/// unique_ptr to handle an %addrinfo linked list provided by %getaddrinfo
typedef std::unique_ptr<addrinfo, detail::addrinfo_deleter> addrinfo_ptr;

同样在 Win32 编程中，许多 API 为您提供 memory，它已使用LocalAlloc分配，因此必须使用LocalFree释放：

    // Custom deleter (for unique_ptr) using Win32 LocalFree
    struct LocalFree_deleter { void operator()(void *ptr) { LocalFree(ptr); } };
    // ...
    std::unique_ptr<LPWSTR[], LocalFree_deleter> argvw(CommandLineToArgvW(cmdline_u16, &argc));

---

您甚至可以 go 更进一步，处理甚至不是指针的东西，而是不透明的“句柄”：同样在 Win32 中，这很常见，甚至不同类型的句柄需要不同的关闭函数； 即使在这种情况下， unique_ptr和自定义删除器也可以拯救：

template<decltype(CloseHandle) ch_fn = CloseHandle>
struct handle_deleter {
    typedef HANDLE pointer;
    void operator()(HANDLE obj) {
        if(obj != NULL && obj != INVALID_HANDLE_VALUE) ch_fn(obj);
    }
};

using unique_handle = std::unique_ptr<HANDLE, handle_deleter<>>;
using unique_find_handle = std::unique_ptr<HANDLE, handle_deleter<FindClose>>;

注意这里handle_deleter提供了一个typedef HANDLE pointer ：这个typedef被unique_ptr用作它存储在其内部的类型，在get() & co 中返回。