Question: Am new to C++ 11 and using threading. I came across a scenario where it's not possible to copy mutex & condition variable objects. The code is like this....

```
class producer {

   public: 
      producer(mutex m, condition_variable cv) 
      {
           mut = m;    // ERROR
           cvar = cv;   // ERROR
       }

    private:
         mutex mut;
         condition_variable cvar;
}

```

When trying to copy the variables in constructor it's giving the error. Seems like copy constructor is set to delete for mutex and cv.

Is there a way to overcome that? I want a producer & consumer class and then pass the mutex & cv from the **main** function.

so basically the call from main function should look like....

```
int main ()
{
    mutex m;
    condition_variable cv;
    //Initialize mutex & cv
    producer prod(m, cv);
}

```

Answer: 
No this is not possible. Features were added in C++ to enable this feature (non copying).

If you think about the implementation are you changing somekind of kernel object? Will that be the same. Probably not. This is by design.
It is impossible by design.

What does it even mean to copy a mutex? What should it do?

Say you wait for a mutex A and some body copies mutex A to mutex B.
Do you still wait for A or for B? or for both of them? No. You should still wait for A.
So other mutex B cannot be a copy of A. So copying is deleted.

Move operation makes sense, but since mutexes are statically allocated, moving them is impossible without changing their addresses - which becomes a nightmare for whoever is waiting on the mutex. Thus move operation is also deleted.

Same criteria holds true for condition variables.

To overcome these problems, you can use pointers to mutexes and condition variables. Say, store them as `std::shared_ptr<std::mutex>` and `std::shared_ptr<std::condition_variable>` if you want a simple design.