C++ 这个锁块是怎么工作的？

我看到一个头文件，如下所示：

#include <pthread.h>

#define lock(x) if(Lock _lock_=x){}else

class Mutex{
    public:
        Mutex(){
            pthread_mutex_init(&mutex_, 0);
        };

        ~Mutex(){
            pthread_mutex_destroy(&mutex_);
        };

        friend class Lock;

    private:
        pthread_mutex_t mutex_;

        void Lock(){
            pthread_mutex_lock(&mutex_);
        };

        void Unlock(){
            pthread_mutex_unlock(&mutex_);
        };
};

class Lock{
    public:
        Lock(Mutex& mutex):mutex_(mutex){mutex_.Lock();};
        ~Lock(){mutex_.Unlock();};

        operator bool() const {
            return false;
        }

    private:
        Mutex& mutex_;
};

---

那么，这个锁宏是如何工作的呢？为什么？

因此，预处理器将就地展开宏（实质上是将其插入代码中）。因此，您的示例变成：

...
Mutex mtx;
if(Lock _lock_=mtx){}else {
  // critical section
}
...

或者，使用更好的格式

...
Mutex mtx;
if(Lock _lock_=mtx)
{
}
else
{
  // critical section
}
...

它通过

Lock

类的构造函数锁定互斥体，

if（）

语句中的表达式总是计算为

false

，因为

Lock

的

操作符bool（）const

的实现，所以执行

else{}/code>部分中的代码

我想我也会提到，我认为这是一个。。。这比必要的方法更复杂。在作用域的开头声明一个新的
Lock
“同样容易”（可能更容易理解），并且完全取消宏。例如，这就是如何使用的。
因此，预处理器将就地展开宏（实质上是将其插入代码中）。因此，您的示例变成：

...
Mutex mtx;
if(Lock _lock_=mtx){}else {
  // critical section
}
...

或者，使用更好的格式

...
Mutex mtx;
if(Lock _lock_=mtx)
{
}
else
{
  // critical section
}
...

它通过
Lock
类的构造函数锁定互斥体，
if（）
语句中的表达式总是计算为
false
，因为
Lock
的
操作符bool（）const
的实现，所以执行
else{}/code>部分中的代码

我想我也会提到，我认为这是一个。。。这比必要的方法更复杂。在作用域的开头声明一个新的
Lock
“同样容易”（可能更容易理解），并且完全取消宏。例如，这就是如何使用的。
因此，预处理器将就地展开宏（实质上是将其插入代码中）。因此，您的示例变成：

...
Mutex mtx;
if(Lock _lock_=mtx){}else {
  // critical section
}
...

或者，使用更好的格式

...
Mutex mtx;
if(Lock _lock_=mtx)
{
}
else
{
  // critical section
}
...

它通过
Lock
类的构造函数锁定互斥体，
if（）
语句中的表达式总是计算为
false
，因为
Lock
的
操作符bool（）const
的实现，所以执行
else{}/code>部分中的代码

我想我也会提到，我认为这是一个。。。这比必要的方法更复杂。在作用域的开头声明一个新的
Lock
“同样容易”（可能更容易理解），并且完全取消宏。例如，这就是如何使用的。
因此，预处理器将就地展开宏（实质上是将其插入代码中）。因此，您的示例变成：

...
Mutex mtx;
if(Lock _lock_=mtx){}else {
  // critical section
}
...

或者，使用更好的格式

...
Mutex mtx;
if(Lock _lock_=mtx)
{
}
else
{
  // critical section
}
...

它通过
Lock
类的构造函数锁定互斥体，
if（）
语句中的表达式总是计算为
false
，因为
Lock
的
操作符bool（）const
的实现，所以执行
else{}/code>部分中的代码

我想我也会提到，我认为这是一个。。。这比必要的方法更复杂。在作用域的开头声明一个新的
Lock
“同样容易”（可能更容易理解），并且完全取消宏。例如，这就是如何使用的。
我们可以在此处进行一些纸上宏扩展：

你的宏=

#define lock(x) if(Lock _lock_=x){}else

以及资讯科技的应用：

Mutex mtx;
lock(mtx) {
  // critical section
}

在宏替换后变为：

Mutex mtx;
if(Lock _lock_=mtx)
{
  // BLOCK 1
}
else
{
  // BLOCK 2
  // critical section
}

因此，
\u lock\u
是从
mtx
复制分配的，它试图通过调用
pthread\u mutex\u lock
锁定互斥体，如果互斥体已被阻止，则会执行和阻止

if
块正在调用
Lock:：operator bool（）
，它总是返回
false
：

运算符bool（）常量{
返回false；
}

由于这总是返回
false
，因此块I标记
块1
，而不会调用关键节代码（
块2
）

你的宏=

#define lock(x) if(Lock _lock_=x){}else

以及资讯科技的应用：

Mutex mtx;
lock(mtx) {
  // critical section
}

在宏替换后变为：

Mutex mtx;
if(Lock _lock_=mtx)
{
  // BLOCK 1
}
else
{
  // BLOCK 2
  // critical section
}

因此，
\u lock\u
是从
mtx
复制分配的，它试图通过调用
pthread\u mutex\u lock
锁定互斥体，如果互斥体已被阻止，则会执行和阻止

if
块正在调用
Lock:：operator bool（）
，它总是返回
false
：

运算符bool（）常量{
返回false；
}

由于这总是返回
false
，因此块I标记
块1
，而不会调用关键节代码（
块2
）

你的宏=

#define lock(x) if(Lock _lock_=x){}else

以及资讯科技的应用：

Mutex mtx;
lock(mtx) {
  // critical section
}

在宏替换后变为：

Mutex mtx;
if(Lock _lock_=mtx)
{
  // BLOCK 1
}
else
{
  // BLOCK 2
  // critical section
}

因此，
\u lock\u
是从
mtx
复制分配的，它试图通过调用
pthread\u mutex\u lock
锁定互斥体，如果互斥体已被阻止，则会执行和阻止

if
块正在调用
Lock:：operator bool（）
，它总是返回
false
：

运算符bool（）常量{
返回false；
}

由于这总是返回
false
，因此块I标记
块1
，而不会调用关键节代码（
块2
）

你的宏=

#define lock(x) if(Lock _lock_=x){}else

以及资讯科技的应用：

Mutex mtx;
lock(mtx) {
  // critical section
}

在宏替换后变为：

Mutex mtx;
if(Lock _lock_=mtx)
{
  // BLOCK 1
}
else
{
  // BLOCK 2
  // critical section
}

因此，
\u lock\u
是从
mtx
复制分配的，它试图通过调用
pthread\u mutex\u lock
锁定互斥体，如果互斥体已被阻止，则会执行和阻止

if
块正在调用
Lock:：operator bool（）
，它总是返回
false
：