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

Question

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

Answer 1

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.

Answer 2

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.