Is a copy-on-return operation executed prior or after lock_guard destructor? [duplicate]

Question

Is the get_a() function safe for race-conditions or do I need to explicitly copy str_ as in get_b() in order to have a thread-safe function?

class Class {
public:
  auto get_a() -> std::string {
    auto&& guard = std::lock_guard{mutex_};
    return str_;
  }
  auto get_b() -> std::string {
    auto&& guard = std::lock_guard{mutex_};
    auto str = str_;
    return str;
  }
private:
  std::mutex mutex_{};
  std::string str_{};
};

Note: I'm aware that there are similar questions here on Stack Overflow, but I could not find one which explicitly answers this question.

Answer 1

[stmt.return]p3:

The copy-initialization of the result of the call is sequenced before the destruction of temporaries at the end of the full-expression established by the operand of the return statement, which, in turn, is sequenced before the destruction of local variables of the block enclosing the return statement.

This means that the following happen in order:

1. The return object is copy-initialized
2. Any temporaries inside the return statement are destroyed
3. Local variables are destroyed

So, we can infer that get_a is completely safe.