compiler optimization

Question

So I have a question for you. :) Can you tell me the output the following code should produce?

#include <iostream>
struct Optimized
{
    Optimized() { std::cout << "ctor" << std::endl; }
    ~Optimized() { std::cout << "dtor" << std::endl; }
    Optimized(const Optimized& copy) { std::cout << "copy ctor" << std::endl; }
    Optimized(Optimized&& move) { std::cout << "move ctor" << std::endl; }
    const Optimized& operator=(const Optimized& rhs) { std::cout << "assignment operator" << std::endl; return *this; }
    Optimized& operator=(Optimized&& lhs) { std::cout << "move assignment operator" << std::endl; return *this; }
};

Optimized TestFunction()
{
    Optimized a;
    Optimized b = a;
    return b;
}

int main(int argc, char* argv[])
{
    Optimized test = TestFunction();
    return 0;
}

My first response would be:

1. ctor
2. copy ctor
3. move ctor
4. dtor
5. dtor
6. dtor

and it IS true, but only if compiler optimization is turned off. When optimization is turned ON then the output is entirely different. With optimization turned on, the output is:

1. ctor
2. copy ctor
3. dtor
4. dtor

With compiler optimization, the test variable is the return variable.

My question is, what conditions would cause this to not be optimized this way?

I have always been taught that returning a struct/class which results in extra copy constructors could better be optimized by being passed in as a reference but the compiler is doing that for me. So is return a structure still considered bad form?

Answer 1

This is known as Copy Elision and is a special handling instead of copying/moving.

The optimization is specifically allowed by the Standard, as long as it would be possible to copy/move (ie, the method is declared and accessible).

The implementation in a compiler is generally referred to, in this case, as Return Value Optimization. There are two variations:

• RVO: when you return a temporary (return "aa" + someString;)
• NRVO: N for Named, when you return an object that has a name

Both are implemented by major compilers, but the latter may kick in only at higher optimization levels as it is more difficult to detect.

Therefore, to answer your question about returning structs: I would recommend it. Consider:

// Bad
Foo foo;
bar(foo);

-- foo can be modified here


// Good
Foo const foo = bar();

The latter is not only clearer, it also allows const enforcement!