c++ - 具有不可移动/可复制类型的 std::tuple

Question

假设我有一个结构 MyStruct其中包含 std::mutex并且仅引用或 pod 成员。我想创建一个 std::tuple包含这种类型。但是作为MyStruct不是复制或移动它不起作用。如果我按以下方式添加一个移动构造函数，它将起作用:

#include <tuple>
#include <mutex>
#include <vector>

struct MyStruct {
        std::vector<double>& vec_;
        int number_;
        std::mutex mutex_;

        MyStruct(std::vector<double>& vec, const int number)
           : vec_(vec), number_(number) {}
        MyStruct(MyStruct&& o) : vec_(o.vec_), number_(o.number_)
        {
                std::lock_guard guard(o.mutex_);
        }
};

int main()
{
        using T = std::tuple<MyStruct,int>;

        std::vector<double> v{1., 2., 3.};
        T t{MyStruct{v, 1}, 2};
}

这样安全吗？最后我只想在 std::tuple 中构造它在进行任何多线程之前，但我如何确保 std::tuple 的元素一旦std::tuple 就不会移动是 build 的吗？或者有没有办法构建一个 std::tuple到位了吗？

Answer 1

您的代码在特定情况下可能是安全的，但如果您希望它在一般情况下是安全的，那么您需要修复您的移动构造函数。移动构造函数必须正确地同步对移出对象状态的访问，并且它必须防止该对象在新对象窃取它后修改状态:

class MyStruct {
  std::vector<double>* vec_; // use a pointer here, not a reference
  int number_;
  std::mutex mutex_;
public:
  MyStruct(std::vector<double>& vec, const int number)
     : vec_(&vec), number_(number) {}
  MyStruct(MyStruct&& o)
  {
    std::lock_guard guard(o.mutex_);
    vec_ = std::exchange(o.vec_, nullptr);
    number_ = std::exchange(o.number_, 0); // doesn't necessarily have to be 0 here
  }
};

您还必须更改任何其他方法来说明移出状态。另请注意，我已将其更改为一个类并将状态设为私有(private)。拥有公共(public)互斥锁和公共(public)数据成员会带来麻烦。为了安全起见，您必须确保对可变状态的所有访问都正确同步。

没有移动构造函数

如果您想避免移动构造函数，那么最明显的解决方案就是避免使用元组。 tuple 旨在与库中的通用代码一起使用。在其他情况下的有效使用存在但很少见。考虑使用结构来存储值:

struct Fixture
{
  MyStruct a;
  int b;
};

这具有命名您的成员(更具可读性)和允许自定义构造函数的优点。

使用 std::tuple

如果你绝对必须使用元组，那么问题还是可以解决的。在构建元组后，您只需要一种方法来构建您的 MyStruct 对象。有几种方法可以做到这一点。这里有两个:

使用std::optional:

int main()
{
  using T = std::tuple<std::optional<MyStruct>,int>;

  std::vector<double> v{1., 2., 3.};
  T t{std::nullopt, 2};

  std::get<0>(t).emplace(v, 1);
}

定义默认构造函数并使用两阶段初始化:

// Add a constructor like the following, once again using a pointer instead of reference
MyStruct() : vec_(nullptr), number_(0) {}

// Add an init method
void init(std::vector<double>& vec, int number)
{
  vec_ = &vec;
  number_ = number;
}

// Later
int main()
{
  using T = std::tuple<MyStruct,int>;

  std::vector<double> v{1., 2., 3.};
  T t{MyStruct{}, 2};

  std::get<0>(t).init(v, 1);
}