C ++ Move Semantics - 包装旧版C API

时间:2015-09-24 12:49:31

标签: c++ c++11 constructor move c++14

我正在使用传统的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是私有的,所有操作都通过一些公共实例函数公开,这些函数隐藏了消费者的遗留API。

构造函数是私有的,因为Thing的实例将从静态工厂或实际获取资源的 named-constructor 返回。这是对该工厂的廉价模仿,使用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>,要么我必须实现移动语义。我不想指定应该使用Thing的模式,所以我选择添加一个move-constructor和move-assignment-operator,如下所示......

    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);

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

    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_uniquemake_shared 实际调用了移动构造函数 - 它没有像我希望的那样被优化掉。

第一个问题:我是否正确实施了 move -constructor和move-assignment-operator? (他们对我来说相当新,这将是我第一次愤怒地使用它。)

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

最后:我是否应该更改任何内容以使代码更好,更快,更简单或更易读?

2 个答案:

答案 0 :(得分:6)

您应该将Thing包装在智能指针中,然后您不必担心复制和移动语义。

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();
}

答案 1 :(得分:2)

struct free_thing{
  void operator()(void* p)const{
    // stuff
    free(p);
  }
};
using upthing=std::unique_ptr<void,free_thing>;

upthing make_thing(stuff){
  void*retval;
  // code
  return upthing(retval);
}

upthing存储在Thing _legacy。使用默认dtor,移动ctor,移动Thing=default)的分配。

销毁代码进入free_thing

你的ctor创造了一切。

现在,用户可以将您的Thing视为仅限移动值类型。

除非确实需要,否则不要编写自己的指针管理器。独特和共享为您做很多事情:如果您编写自己的智能指针,请将它们用作内部内容。