How to use lock_guard when returning protected data

Question

I have a question concerning the use of boost::lock_guard (or similar scoped locks) and using variables that should be protected by the lock in a return statement.

How is the order of destroying local objects and copying the return value? How does return value optimization affect this?

Example:

Data Class::GetData()
{
    boost::lock_guard<boost::mutex> lock(this->mMutex);
    return this->mData;
}

Would this be correct (if mData is the variable protected by mMutex)? Or would I have to use a local scope and a temporary like shown in the example below:

Data Class::GetData()
{
    Data ret;
    {
        boost::lock_guard<boost::mutex> lock(this->mMutex);
        ret = this->mData;
    }
    return ret;
}

Answer 1

Just a straight return as in your first example is correct. The return value is constructed before the local variables are destroyed, and thus before the lock is released.

Answer 2

How is the order of destroying local objects and copying the return value?

Generally, stack objects are destroyed in reverse order of creation. As previously stated, both approaches you specify will provide the desired behavior.

How does return value optimization affect this?

RVO should not be a concern here - all this does is construct the output object directly into the stack frame buffer - avoiding the overhead of creating a named temporary object (as in your 2nd example above). This is done before local destructors are invoked.

You're best off using the code from example 1 above.

Answer 3

Both pieces are equivalent. In fact for case #1 - C++ compiler will create structure described in case #2. So #1 is preferable.