通过引用“ std :: lock_guard”返回共享对象是否安全？ <mutex> “？

Question

#include <vector>
#include <string>
#include <mutex>
#include <future>

using namespace std;

mutex g_mtx;
vector<string> g_coll;

void Cleaner()
{
    lock_guard<mutex> lock(g_mtx);
    g_coll.clear();
}

const vector<string>& Getter()
{
    lock_guard<mutex> lock(g_mtx);
    return g_coll;
}

int main()
{
    g_coll = { "hello" };
    auto fut = async([&]()
    {
        Cleaner();
    });

    auto returned_coll = Getter();
    fut.get();
}

If Cleaner is executed after return g_coll; , does the C++ standard guarantee that returned_coll contains { "hello" } ?

Answer 1

No, this is not safe.

Semantically, the order of events when a function of non-void return type returns is as follows:

1. The expression in the return statement is evaluated.
2. The return value is copy-initialized from said expression.
3. Automatic local variables are destroyed in the reverse order of construction.
4. Control is returned to the caller.

Note that returned_coll is not the return value. Rather, Getter() is the return value. The initialization of returned_coll from the lvalue returned by Getter() occurs after step 4.

Therefore, when returned_coll is copy-initialized from Getter() , the mutex held by Getter will have already been released, which means the initialization of returned_coll may race with the access in Cleaner .