Why doesn't std::move on a std::unique_lock have any effect?

Question

I have the following C++(11) code:

#include <mutex>

void unlock(std::unique_lock<std::mutex> && ulock)
{
}

int main(void)
{
    std::mutex m;
    std::unique_lock<std::mutex> ulock(m);

    unlock(std::move(ulock));

    if (ulock.mutex() == &m || ulock.owns_lock())
    {
        throw std::runtime_error("");
    }

    return 0;
}

What I can't figure out is why the mutex is still held after the return from unlock(). My expectation is that the std::move() causes the lock to go out of scope (and become unlocked by the destructor) upon return from the call to unlock(). At the very least, it seems like the std::move() should have caused ulock to become "unbound" from the mutex m.

What am I missing?

Answer 1

void unlock(std::unique_lock<std::mutex> && ulock)

Here ulock is a reference. A special kind of reference, but still a reference. It is just an alias for another object. Its creation does not involve creation of a new object, or any kind of ownership transfer. Likewise, end of its lifetime does not lead to any destructor call, it just means that you lost the alias for referring to some other object (not that it matters, since the function is ending anyway).

If you want to transfer ownership, you need an object, so pass by value instead of by reference:

void unlock(std::unique_lock<std::mutex> ulock)

Now, you will have to move the original lock, since std::unique_lock does not support copy construction, only move construction.