具有互斥成员的默认移动构造函数

Question

我有一个带有已删除复制构造函数的类，我正在尝试将互斥锁成员放入如下内容：

struct A {
    A(const A &other) = delete;
    A& operator=(const A &other) = delete;
    A(A&& other) = default;
    A& operator=(A &&other) = default;

    std::mutex lock;
};

编译器抱怨我试图调用已删除的复制构造函数，我总结这是由于 std::mutex 类型是不可移动的。如何让互斥锁成员以最少的麻烦与移动构造函数一起玩？我实际上并不想将互斥体成员本身移动到新构造的对象中，并且实际上希望每个移动的对象只构造它自己的互斥体

Answer 1

我实际上并不想将互斥体成员本身移动到新构造的对象中，并且实际上希望每个移动的对象只构造它自己的互斥体

然后简单地定义你的移动构造函数来构造一个新的互斥体：

struct A {
    A(const A &other) = delete;
    A& operator=(const A &other) = delete;
    A(A&& other)
        : lock()
    {
    }

    A& operator=(A &&other) = delete;

    std::mutex lock;
};

移动分配仍然是一个问题，可能应该被删除。除非你能回答这个问题：当你被分配一个新值时，现有的 mutex 成员会发生什么？特别是：如果在现有互斥​​锁被锁定时为您分配了一个新值怎么办？

Answer 2

作为为您的类提供自定义移动操作的替代方法，您可以创建一个通用包装器：

template <class T>
class PerObject
{
  T data;
public:
  PerObject() = default;
  PerObject(const PerObject&) {}
  PerObject& operator= (const PerObject&) { return *this; }
  T& operator* () const { return data; }
  T* operator-> () const { return &data; }
};

并像这样使用它：

struct A {
    A(const A &other) = delete;
    A& operator=(const A &other) = delete;
    A(A&& other) = default;
    A& operator=(A &&other) = default;

    PerObject<std::mutex> lock;
};

包装器的复制（和移动）操作是无操作的，因此包含包装器的对象将始终包含它开始时的那个。

---

警告：但是，根据您的班级使用互斥锁的方式，上述内容实际上可能很危险。如果互斥锁用于保护类中的其他数据，那么它可能在分配对象时被锁定，因此无论如何您都必须提供手动移动操作。在这种情况下，代码可能看起来像这样：

struct A {
    A(A&& other) : lock{}, /* anything else you need to move-construct */
    {
      // Note: it might even be necessary to lock `other.lock` before moving from it, depending on your class's exact semantics and expected use.
    }
    A& operator=(A &&other)
    {
      if (this == &other) return *this;  // Otherwise, double-locking would be possible

      // If you need to lock only this object:
      std::unique_lock<std::mutex> l(lock);
      // Alternatively, if you need to lock both objects:
      std::scoped_lock l(lock, other.lock);

      // Now move data from other to this

      return *this;
    }

    std::mutex lock;
};

Answer 3

一种方法是让你的移动构造函数在调用时创建新的mutex。

 A(A&& other): lock()
 {
     //... move other things
 }

您也可以将std::unique_ptr() 用于std::mutex，因为它是可移动的。

struct A {
    A(const A &other) = delete;
    A& operator=(const A &other) = delete;
    A(A&& other) = default;
    A& operator=(A &&other) = default;

    std::unique_ptr<std::mutex> lock;
};

A::A() : lock(new std::mutex())

使用这种方法，您不会在每次移动对象时都创建新的互斥体，这将消除一些开销。