C++ passing a mutex to a member variable in the constructor - c++

Question

I have a problem with passing a mutex to my class. I have a class named Test with the a member variable called m_Mutex. In the constructor I want to transfer the parameter mutex to m_Mutex.
My class:
#include <mutex>
class Test
{
public:
Test(mutex &mtx) :
m_Mutex(mtx)
{
}
private:
mutex m_Mutex;
};
My main:
int main()
{
mutex mutex1;
Test t(mutex1);
return 0;
}
Error:
function "std::mutex::mutex(const std::mutex &)" (declared at line 88
of "c:\Program Files (x86)\Microsoft Visual
Studio\2017\Professional\VC\Tools\MSVC\14.11.25503\include\mutex")
cannot be referenced -- it is a deleted function
Why am I getting this error and how can I fix it that I am able to pass the mutex?

Answer 1

In short terms: you can't. Mutexes are neither copyable nor movable. And they aren't for a good reason. If however you want to achieve this nontheless, you might pass it by using a unique_ptr:
class A {
unique_ptr<mutex> mutexPtr;
A(unique_ptr<mutex> ptr) : mutexPtr(std::move(ptr)) { }
};
A a{std::make_unique<mutex>()};
Note that if you want to share the mutex between different objects, you should use shared_ptr or weak_ptr instead.

Answer 2

In the constructor I want to transfer the parameter mutex to m_Mutex
Unfortunately you can't. std::mutex is not copyable and not moveable. One thing you can do if you want to declare the mutex somewhere else is to store a reference to the mutex like
class Test
{
public:
Test(mutex &mtx) :
m_Mutex(mtx)
{
}
private:
mutex& m_Mutex;
};

Answer 3

#include <mutex>
class Test
{
public:
Test(std::mutex &mtx) :
m_Mutex(mtx)
{
}
private:
std::mutex &m_Mutex; // note the "&"
};
int main()
{
std::mutex mutex1;
Test t(mutex1);
return 0;
}

Answer 4

Just keep mutex inside your class (probably as static member) and if you need to allow other classes to use it provide access:
class Test
{
public:
Test() {}
std::mutex &mux() { return m_Mutex; }
private:
mutex m_Mutex;
};
or even this:
class Test {
public:
using lock_t = std::scoped_lock<std::mutex>;
Test() {}
lock_t lock() { return lock_t( m_Mutex ); }
private:
mutex m_Mutex;
};
usage:
Test t;
{
auto lock = t.lock();
// object t is locked till end of the block
}

Answer 5

Just make it a reference
Your mutex must be the same for all instances of your class, if it's not the case the lock you do in one instance of your class won't be active for the other one.
#include <mutex>
#include <iostream>
using namespace std;
class Test
{
public:
Test(mutex &mtx) :
m_Mutex(mtx)
{
m_Mutex.lock();
i++;
cout << "Test " <<i<<endl;
m_Mutex.unlock();
}
private:
mutex& m_Mutex;
static int i;
};
int Test::i =0;
int main()
{
mutex mutex1;
Test t1(mutex1);
Test t2(mutex1);
return 0;
}
see it live : https://wandbox.org/permlink/6YJFG3MI7m7RbfoL