如何在类成员互斥上使用std :: lock_guard

Question

In the following code the bad method fails to compile, but the good method does not. Why is providing the explicit reference to this making a difference here?

#include <mutex>

class Foo
{
 private:
  std::mutex lock_;

 public:
  Foo() = default;
  ~Foo() = default;

  void bad();
  void good();
};

void Foo::bad()
{
  std::lock_guard<std::mutex>(lock_);
}

void Foo::good()
{
  std::lock_guard<std::mutex>(this->lock_);
}

int main()
{
  return 0;
}

compile error:

test.cpp: In member function ‘void Foo::bad()’:
test.cpp:18:36: error: no matching function for call to ‘std::lock_guard<std::mutex>::lock_guard()’
   std::lock_guard<std::mutex>(lock_);

You can play with the ideone if you want.

Answer 1

This is an instance of the most vexing parse. The parentheses here don't do what you think they do. This:

std::lock_guard<std::mutex>(lock_);

is equivalent to:

std::lock_guard<std::mutex> lock_;

which should make it clear why what you're trying to do won't compile, and why you're getting the compile error you're getting. What you need to do is provide a name for the lock_guard :

std::lock_guard<std::mutex> _(lock_);

The good version works because the this-> qualification prevents the name from being able to be treated as an identifier.

---

Note: lock_ is a std::mutex and not any kind of lock, which makes it a very confusing name. You should name it something more reflective of what it is. Like mutex_ .

Answer 2

If you declare your lock_guard correctly, they both work:

void Foo::bad()
{
  std::lock_guard<std::mutex> x{lock_};
}

void Foo::good()
{
  std::lock_guard<std::mutex> y{this->lock_};
}

Using a temporary is almost useless, because the lock gets released immediately. Correct usage is to declare a local variable with automatic lifetime.

Answer 3

例如，您需要实际创建变量

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