How does multiple assignment (a = b) = c syntax work? [closed]

Question

How does a statement like (a = b) = c; work in C++, assuming a,b and c are ints or any other primitive type?

Answer 1

The assignment expression a = b is not an lvalue in C, but it is in C++:

• C11, 6.5.14 (Assignment operators):

  An assignment operator stores a value in the object designated by the left operand. An assignment expression has the value of the left operand after the assignment, but is not an lvalue.

• C++14, 5.18 [expr.ass] (Assignment and compound assignment operators):

  The assignment operator (=) and the compound assignment operators all group right-to-left. All require a modifiable lvalue as their left operand and return an lvalue referring to the left operand.

In the evolution of C++ from C, several expressions were made "lvalue-aware", as it were, because lvalues are much more important in C++ than in C. In C, everything is trivial (trivially copyable and trivially destructible, all in the words of C++), so lvalue-to-rvalue conversions (or "lvalue conversions", as C calls them) aren't painful. In C++, copying and destruction are non-trivial concepts, and by making expressions preserve lvalue-ness, a lot of copying and destructing can be avoided that was never necessary to begin with.

Another example is the conditional expression (a ? b : c), which is not an lvalue in C, but can be a lvalue in C++.

Another interesting artefact of this language evolution is that C has four well-defined storage durations (automatic, static, thread-local, dynamic), but in C++ this becomes more muddled, since temporary objects are a non-trivial concept in C++ that almost calls for its own storage duration. (E.g. Clang internally has a fifth, "full expression" storage duration.) Temporaries are of course the result of lvalue-to-rvalue conversion, so by avoiding the conversion, there's one less thing to worry about.

(Please note that all of this discussion only applies to the respective core language expressions. C++ also has the separate, unrelated feature of operator overloading, which produces function call expressions, which have all the usual semantics of function calls and have nothing to do with operators except for the syntax. For example, you can define an overloaded operator= that returns a prvalue or void if you so wish.)

Answer 2

Informally, in C++, for builtin types, the result of a = b is a reference to a; you can assign a value to that reference, just as with any other reference. So (a = b) = c assigns the value of b to a, and then assigns the value of c to a.

For user-defined types this may not apply, although the usual idiom is for an assignment operator to return a reference to the left-hand argument, so the behavior of user-defined types mimics the behavior of builtin types:

struct S {     S& operator=(const S& rhs) {         return *this;     } }; 

Now, S a, b, c; (a = b) = c; means call a.operator=(b), which returns a reference to a; then call S::operator= on that result and c, effectively calling a.operator=(c).