冲突声明 std::lock_guard<std::mutex></std::mutex>

Question

I don't understand why the following code returns an error.

#include <mutex>

int main() {
    std::mutex mtx;
    std::lock_guard<std::mutex> (mtx);
}

lock.cpp: In function 'int main()':

lock.cpp:5:37: error: conflicting declaration 'std::lock_guardstd::mutex mtx' std::lock_guardstd::mutex (mtx);

lock.cpp:4:16: note: previous declaration as 'std::mutex mtx' std::mutex mtx;

But, the following code compiles correctly.

class Test {
public:
    void lock() {
        std::lock_guard<std::mutex> (this->mtx_);
        std::lock_guard<std::mutex> (this->mtx_);
    }

private:
    std::mutex mtx_;
};

But, the following code is not ok.

int main() {
    std::lock_guard<std::mutex> (mtx);
    std::lock_guard<std::mutex> (mtx);
}

Answer 1

You declared the variable mtx twice

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

The first declaration may be equivalently rewritten like

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

Or the second declaration may be rewritten like

std::mutex mtx;
std::lock_guard<std::mutex> mtx;

That is you may enclose a declarator in parentheses.

Thus the identifier mtx is declared twice with different types.

It seems you forgot to specify an identifier in the second declaration.:) Something like

std::lock_guard<std::mutex> my_lock( mtx );

EDIT: After you updated your question with a new code snippet

class Test {
public:
    void lock() {
        std::lock_guard<std::mutex> (this->mtx_);
        std::lock_guard<std::mutex> (this->mtx_);
    }

private:
    std::mutex mtx_;
};

then these records

std::lock_guard<std::mutex> (this->mtx_);
std::lock_guard<std::mutex> (this->mtx_);

are not declarations. They are expressions that use the data member (an expression of accessing a data member) this->mtx_ . That is the expression this->mtx_ is not an identifier.

Answer 2

Finding out the problem:

In first example:

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

Here you have declared a variable mtx of type std::mutex . The next line is ambiguous. It can be treated as an expression with declaring a variable of type std::lock_guard<std::mutex> , but since you do not passed a parameter to lock_guard constructor, it is being treated as a pure declaration with syntax *type* (*identifier*) . You can find more about resolving ambiguous here .

In second example:

void lock() {
    std::lock_guard<std::mutex> (this->mtx_);
    std::lock_guard<std::mutex> (this->mtx_);
}

You are trying to use syntax *type* *identifier* (*constructor arguments*) , and pass an already existent member mtx_ of your class and there is no variable name. There is no ambiguity and no errors because of absent variable name. It is just to declaration of anonymous variables.

The third example is definitely not ok because your just repeating the mistake from ex. 1 twice, by declaring two variables named mtx .

int main() {
    std::lock_guard<std::mutex> (mtx);
    std::lock_guard<std::mutex> (mtx);
}

How to resolve:

As I already mentioned in comment, you should better use a name for your lock. Either it can be

std::lock_guard<std::mutex> lock(mtx);

, or if like using parentheses to distract yourself

std::lock_guard<std::mutex>(lock)(mtx);