我正在使用旧版 C API，在该 API 下获取某些资源非常昂贵，释放该资源绝对至关重要。我正在使用 C++14，我想创建一个类来管理这些资源。这是这件事的基本框架...

class Thing
{
private:
    void* _legacy;

public:
    void Operation1(...);
    int Operation2(...);
    string Operation3(...);

private:
    Thing(void* legacy) :
        _legacy(legacy)
    {
    }
};

这不是真正的单例模式。没有什么是静态的，可能有很多 Thing例如，所有这些都管理着自己的遗留资源。此外，这不仅仅是一个智能指针。包裹指针，_legacy是私有(private)的，所有操作都通过一些对消费者隐藏遗留 API 的公共(public)实例函数公开。

构造函数是私有(private)的，因为 Thing 的实例将从实际获取资源的静态工厂或命名构造函数返回。这是该工厂的廉价仿制品，使用 malloc()作为将调用遗留 API 的代码的占位符 ...

public:
    static Thing Acquire()
    {
        // Do many things to acquire the thing via the legacy API
        void* legacy = malloc(16);

        // Return a constructed thing
        return Thing(legacy);
    }

这里是负责释放遗留资源的析构函数，同样，free()只是一个占位符...

    ~Thing() noexcept
    {
        if (nullptr != _legacy)
        {
            // Do many things to free the thing via the legacy API
            // (BUT do not throw any exceptions!)
            free(_legacy);
            _legacy = nullptr;
        }
    }

现在，我想确保恰好一个遗留资源由恰好一个 Thing 实例管理。 .我不想要 Thing 的消费者类随意传递实例 - 它们必须在本地属于类或函数，直接或通过 unique_ptr , 或者用 shared_ptr 包裹可以传递。为此，我删除了赋值运算符和拷贝构造函数……

private:
    Thing(Thing const&) = delete;
    void operator=(Thing const&) = delete;

然而，这增加了一个额外的挑战。要么我必须更改我的工厂方法以返回 unique_ptr<Thing>或 shared_ptr<Thing>或者我必须实现 move 语义。我不想规定 Thing 的模式应该使用所以我选择添加一个 move 构造函数和 move 赋值运算符如下...

    Thing(Thing&& old) noexcept : _legacy(old._legacy)
    {
        // Reset the old thing's state to reflect the move
        old._legacy = nullptr;
    }

    Thing& operator= (Thing&& old) noexcept
    {
        if (&old != this)
        {
            swap(_legacy, old._legacy);
        }
        return (*this);
    }

完成这一切后，我可以使用 Thing作为一个本地人，把它搬来搬去……

    Thing one = Thing::Acquire();
    Thing two = move(one);

我无法通过尝试提交 self 分配来打破模式:

    Thing one = Thing::Acquire();
    one = one;                      // Build error!

我还可以制作 unique_ptr对一个...

    auto three = make_unique<Thing>(Thing::Acquire());

或者一个shared_ptr ...

    auto three = make_shared<Thing>(Thing::Acquire());

一切都如我所料，我的析构函数在我所有的测试中都在正确的时刻运行。事实上，唯一令人恼火的是 make_unique和 make_shared两者实际上都调用了 move 构造函数——它并没有像我希望的那样被优化掉。

第一个问题:我是否正确实现了 move 构造函数和 move 赋值运算符？ (它们对我来说相当陌生，这将是我第一次在愤怒中使用它们。)

第二个问题:请对此模式发表评论!这是将遗留资源包装在 C++14 类中的好方法吗？

最后:我是否应该更改任何内容以使代码更好、更快、更简单或更具可读性？

最佳答案

您应该将您的 Thing 包装在一个智能指针中，这样您就无需担心复制和 move 语义。

class Thing
{
private:
    void* _legacy;

public:
    void Operation1(...);
    int Operation2(...);
    string Operation3(...);

    Thing(const Thing&) = delete;
    Thing(Thing&&) = delete;
    Thing& operator=(const Thing&) = delete;
    Thing& operator=(Thing&&) = delete;

    static std::shared_ptr<Thing> acquire() {
        return std::make_shared<Thing>();
    }

private:
    Thing() : _legacy(malloc(16)) {
         // ...
    }

    ~Thing() {
        free(_legacy);
    }
};

同样，你可以用unique_ptr来做到这一点:

std::unique_ptr<Thing> acquire() {
    return std::make_unique<Thing>();
}

你似乎暗示你只想拥有这个东西的一个实例，尽管即使在你的解决方案中你也没有尝试做那样的事情。为此，您需要静态变量。但请记住，在这种情况下，您的资源只会在您的 main() 函数退出后被释放。例如:

static std::shared_ptr<Thing> acquire() {
    static std::shared_ptr<Thing> instance;
    if (!instance) {
        instance = std::make_shared<Thing>();
    }
    return instance;
}

或者 unique_ptr 版本:

static Thing& acquire() {
    static std::unique_ptr<Thing> instance;
    if (!instance) {
        instance = std::make_unique<Thing>();
    }
    return *instance;
}

或者，您可以使用 weak_ptr 在程序范围内获取一个实例，当没有人使用它时，它会被释放。在这种情况下，您将无法为此目的使用 unique_ptr。如果对象被释放然后再次需要，此版本将重新创建对象。

static std::shared_ptr<Thing> acquire() {
    static std::weak_ptr<Thing> instance;
    if (instance.expired()) {
        instance = std::make_shared<Thing>();
    }
    return instance.lock();
}

关于C++ move 语义 - 包装遗留 C API，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32761770/