A() = A() - why does it compile?

class A {};


int main() {
A() = A();
return 0;
}

Why does this code compile? Shouldn't be there some error that on the left side of assignment operator should be placed lvalue? Is A() lvalue? g++ 4.7 version

3913 次浏览
小开
最佳答案

For built-in types, you'd be correct: the built-in assignment operator requires a modifiable lvalue on the left hand side.

However, this is not using the built-in operator, but the overload that's implicitly declared by the class. This is a member function, equivalent to

A().operator=(A());

and member functions can be called on rvalues.

小开

If you really want, you can make it not compile with C++11:

class A {
template <typename T>
void operator=(T&&) && = delete; // no op= for rvalues


// generate other special members normally
A() = default;
A(A const&) = default;
A(A&&) = default;
~A() = default;
// op= only for lvalues
A& operator=(A&&) & = default;
A& operator=(A const&) & = default;
};


int main() {
A() = A(); // error
return 0;
}

(live example)

Note the & and && (aka ref-qualifiers) at the end of the declarations of the various operator= forms. This makes those declarations be selected for lvalues and rvalues respectively. However, the rvalue version, when selected by overload resolution causes the program to be ill-formed because it is deleted.

The default generated operator=, however, does not have any ref-qualifier, meaning it can be called for both lvalues and rvalues; that's why the code in the question compiles, even though A() is an rvalue.

小开

C++ compiler provides all classes with a default constructor, that's what happening, with respect to your code, when you say A()=A(); it just invokes the constructor with a nameless object and the function returns reference to the constructed object (implicit). That's it...


提交答案