Why is the move constructor called here?

Question

Here is a code sample from a C++ quiz:

#include <iostream>
struct X {
    X(const char *) { std::cout << 1; }
    X(const X &) { std::cout << 2; }
    X(X &&) { std::cout << 3; }
};

X f(X a) {
    return a;
}

X g(const char * b) {
    X c(b);
    return c;
}

int main() {
    f("hello");
    g("hello");
}

What will be the output of the program?

I think this way:

1. f(X a) is called, and the constructor implicitly converts const char* to X, so the output is 1
2. As we don't have an object to store the return value in, the return value is discarded, no output
3. g(const char*) is called, and X c(b) X(const char*) The output is 1
4. The return value is one more time discarded - no output

So the answer is 11. The answer which is given to the quiz is 131. The answer, which I get with g++ 4.4.4-13 is 121.

It is said that this code was compiled with this command:

g++ -std=c++11 -Wall -Wextra -O -pthread

Where does the middle number come from? And why can it be 3 or 2?

Answer 1

In theory, this can print any of 131, 13313, 1313, and 1331. It's pretty silly as a quiz question.

• f("hello");:

  • "hello" is converted to a temporary X via the converting constructor, prints 1.
  • The temporary X is used to initialize the function argument, calls the move constructor, prints 3. This can be elided.
  • x is used to initialize the temporary return value, calls the move constructor, prints 3. It's a function parameter, so no elision is allowed, but the return is an implicit move.

• g("hello");

  • "hello" is used to construct c via the converting constructor, prints 1.
  • c is used to initialize the temporary return value, calls the move constructor, prints 3. This can be elided.

Remember that functions always have to construct the thing they return, even if it's just discarded by the calling code.

As to printing 2, that's because the ancient compiler you are using doesn't implement the implicit-move-when-returning-a-local-variable rule.

Answer 2

Copy elision applies to the return statement in g, and possibly elsewhere. Quoted from cppreference:

Copy elision is the only allowed form of optimization that can change the observable side-effects. Because some compilers do not perform copy elision in every situation where it is allowed (e.g., in debug mode), programs that rely on the side-effects of copy/move constructors and destructors are not portable.

So, to your example code, the output cannot be reliably predicted across different implementations.