Question

This program:

#include <iostream>
struct T {
    T() {}
    T(const T &) { std::cout << "copy constructor "; }
    T(T &&) { std::cout << "move constructor "; }
};
int main() {
    ([](T t) -> T { return t; })({}); std::cout << '\n';
    ([](T t) -> T { return void(), t; })({}); std::cout << '\n';
    ([](T t) -> T { return void(), std::move(t); })({}); std::cout << '\n';
}

when compiled by gcc-4.7.1 outputs (link):

move constructor 
copy constructor 
move constructor 

Why does the comma operator have this effect? The standard says:

5.18 Comma operator [expr.comma]

1 – […] The type
and value of the result are the type and value of the right operand; the result is of the same value category as its right operand […]. If the value of the right operand is a temporary, the result is that temporary.

Have I missed something that allows the comma operator to affect the semantics of the program, or is this a bug in gcc?

Answer 1

Automatic move is based on eligibility for copy elision:

§12.8 [class.copy] p32

When the criteria for elision of a copy operation are met or would be met save for the fact that the source object is a function parameter, and the object to be copied is designated by an lvalue, overload resolution to select the constructor for the copy is first performed as if the object were designated by an rvalue. […]

And copy elision in turn is allowed when the return expressions is the name of an automatic object.

§12.8 [class.copy] p31

in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object (other than a function or catch-clause parameter) with the same cv-unqualified type as the function return type, the copy/move operation can be omitted by constructing the automatic object directly into the function’s return value

With the comma operator inserted, the expression is not the name of an automatic object anymore, but only a reference to one, which suppresses copy elision.