Nsryjdtyk

Assume I have a struct MyStruct which contains a std::mutex and only reference or pod members. I want to create a std::tuple containing this type. But as MyStruct is not copy- or moveable it doen't work. It is working if I add a move constructor in the following way:

#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};

}

Is this safe? In the end I only want to construct it inside the std::tuple before any multi-threading is going on, but how can I ensure that the elements of the std::tuple are not moved once the std::tuple is constructed? Or is there a way to construct a std::tuple in place?

Your code may be safe in particular circumstances, but if you want it to be safe in general, then you need to fix up your move constructor. The move constructor must properly synchronize access to the moved-from object's state, and it must prevent that object from modifying the state once the new object has stolen it:

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

  }

};

You will also have to change any other methods to account for the moved-from state. Also note that I've changed this to a class and made the state private. Having a public mutex and public data members invites trouble. For safety, you must ensure that all access to the mutable state is properly synchronized.

Without the Move Constructor

If you want to avoid the move constructor, then the most obvious solution is to avoid using a tuple. tuple is intended for use with generic code in libraries. Valid uses in other contexts exist but are rare. Consider using a struct to store the values instead:

struct Fixture

{

  MyStruct a;

  int b;

};

This has the advantage of naming your members (which is more readable) and allowing custom constructors.

Using a std::tuple

If you absolutely must use a tuple, then the problem is still solvable. You just need a way to construct your MyStruct object after the tuple is constructed. There a few ways you might do that. Here are two:

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

}

Define a default constructor and use two-phase initialization:

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

}