C++句柄类抽象

Question

我正在尝试使用类来抽象原始句柄的显式创建和销毁。实际句柄存储为私有类成员（这样用户就不会与较低级别的细节交互），它在构造时创建并在销毁时销毁。是否有某种设计模式可以帮助实现下面的代码试图实现的目标？

请注意，可能存在大量相互依赖的类，因此用大量友元语句污染每个类既乏味又不好。

#include <memory>

// Handle types may vary
typedef uint32_t A_Handle;
typedef uint32_t B_Handle;
typedef int64_t C_Handle;

extern void createA(A_Handle*);
extern void destroyA(A_Handle);
extern void createB(B_Handle*);
extern void destroyB(B_Handle);
extern void createC(C_Handle*, A_Handle, B_Handle);
extern void destroyC(C_Handle, A_Handle, B_Handle);

class A
{
private:
    A_Handle handle_;
public:
    A()
    {
        createA(&handle_);
    }

    ~A()
    {
        destroyA(handle_);
    }

    A(const A&) = delete;

    A& operator=(const A&) = delete;
};

class B
{
private:
    B_Handle handle_;
public:
    B()
    {
        createB(&handle_);
    }

    ~B()
    {
        destroyB(handle_);
    }

    B(const B&) = delete;

    B& operator=(const B&) = delete;
};

class C
{
private:
    C_Handle handle_;
public:
    std::shared_ptr<A> a;
    std::shared_ptr<B> b;

    C(const std::shared_ptr<A>& a, const std::shared_ptr<B>& b)
        : a(a)
        , b(b)
    {
        // Error a->handle_ and b->handle_ is private
        createC(&handle_, a->handle_, b->handle_);
    }

    ~C()
    {
        // Error a->handle_ and b->handle_ is private
        destroyC(handle_, a->handle_, b->handle_);
    }

    C(const C&) = delete;

    C& operator=(const C&) = delete;
};

// ...

int main()
{
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    std::shared_ptr<C> c = std::make_shared<C>(a, b);

    // ...

    return EXIT_SUCCESS;
}

Answer 1

是否有某种设计模式可以帮助实现下面的代码试图实现的目标？

是的。称为Resource Acquisition Is Initialization，简称RAII。您的第一次尝试是正确的方向，但它可能是不完整的。可能需要担心的是，通常多次“销毁”原始句柄是错误的。因此，您应该建立一个“类不变量”，作为每个成员函数的后置条件，该类的任何两个实例都不会拥有相同的原始句柄。您的课程目前违反了这种不变量。考虑复制实例时会发生什么。有一个经验法则称为五法则（以前的三法则），这将有助于建立该不变量。

对于私有访问和回避朋友，一个好的解决方案是提供一个公共的getter：

class A
{
public
    A_Handle get_handle() { return handle; }

成员仍然被封装，类的用户将无法破坏不变量，因为他们无法修改它。

Answer 2

您不必为此推出自己的解决方案。相反，您可以将std::unique_ptr 与自定义删除程序一起使用，该删除程序知道当unique_ptr 超出范围时如何销毁句柄。

这是一个示例，使用FILE * 作为“句柄”：

#include <cstdio>
#include <memory>

int main ()
{
    FILE *f = std::fopen ("myfile", "r");
    if (f)
    {
        std::unique_ptr <FILE, decltype (&std::fclose)> upf (f, std::fclose);
        // do things with the open file
        // ...
        // file will be closed here, when upf goes out of scope
    }
}

如果您的句柄不是指针类型，您可以将其转换为void *（大多数句柄适合void *)。例如：

#include <sys/stat.h>
#include <fcntl.h>
#include <cstdint>
#include <memory>

int main ()
{
    int fd = open ("myfile", O_RDONLY);
    if (fd >= 0)
    {
        std::unique_ptr <void, void (*) (void *)> upfd
            ((void *) (uintptr_t) fd, [] (void *fd) { close ((int) (uintptr_t) fd); });
        // do things with the open file
        // ...
        // file will be closed here, when upfd goes out of scope
    }
}

当然，您可以为那些看起来很复杂的模板定义类型别名，以使代码更整洁。

std::unique_ptr 有一些不错的功能，包括删除的复制构造函数和可行的移动构造函数。此外，如果您需要共享所有权语义（也称为引用计数），您可以使用 std::shared_ptr 使用类似的技巧。