是否有 std::lock_guard 的简写<std::mutex>锁（米）？

Question

Exactly what the question states. In C++, ideally 11, but curious about 14 and later too, is there a shorthand syntax for:

std::mutex someMutex;
std::lock_guard<std::mutex> lg(someMutex);

Ideally something that infers the type of mutex to avoid the refactoring if I ever wanted to change to a std::recursive_mutex .

In other words, a way to do this:

std::mutex someMutex;
std::lock_guard lg(someMutex);

Or

auto lg = make_lock_guard(someMutex);

For all the type deduction powers of modern C++, it just seems awfully redundant to go typing std::lock_guard<std::mutex> every time I want to make one.

Answer 1

For pre-C++17:

template<class Mutex>
std::lock_guard<Mutex> make_lock_guard(Mutex& mutex) {
    mutex.lock();
    return { mutex, std::adopt_lock };
}

Use as:

std::mutex someMutex;
auto&& lg = make_lock_guard(someMutex);

This takes advantage of the fact that copy-list-initialization doesn't create an additional temporary (even conceptually). The one-parameter constructor is explicit and can't be used for copy-list-initialization, so we lock the mutex first and then use the std::adopt_lock constructor.

The return value is then directly bound to lg , which extends its lifetime to that of the reference, once again creating no temporary (even conceptually) in the process.

Answer 2

In addition to what @TC's answer hinted at, here's the C++17 way:

auto lock = std::lock_guard(someMutex);

You can read about the changes in this proposal: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0091r3.html

Answer 3

Both current answers suggest using the auto keyword to avoid typing the type name. It's not wrong but I prefer my code to contain the typename and so use the auto keyword very sparingly. I would advocate aliasing the type:

using MutexLockGuard = std::lock_guard<std::mutex>;

Answer 4

For C++17 and newer use just:

std::lock_guard lock(mutex)

As template deduction will do its job for you.