Why isn't the copy-constructor called when returning LOCAL variable

Question

I can't figure out why the copy-constructor is not called when I try to return a local variable defined within a function. See the following simplified example:

#include <iostream>
using namespace std;

class X {
public:
    X() { cout << "Default Constructor" << endl; }
    X(const X&) { cout << "Copy Constructor" << endl; }
};

X f(X x) { return x; }

X g() { 
    X y;
    return y;
}

int main() {
    cout << "First create an object" << endl;
    X a;
    cout << "Call f()" << endl;
    f(a);
    cout << "Call g()" << endl;
    g();
}

The output of the complied program is as follows

First create an object
Default Constructor
Call f()
Copy Constructor
Copy Constructor
Call g()
Default Constructor

I understand what's going on when calling f(), but have no idea why return y inside the call of g() does not trigger the copy-constructor.

Because the compiler saves you the possible performance hit from copying with NRVO. — chris, Dec 30 '13 at 10:31
http://en.wikipedia.org/wiki/Copy_elision http://en.wikipedia.org/wiki/Return_value_optimization — Kaustav Ray, Dec 30 '13 at 10:33
follow-up question: why does the compiler not eliminate the copy for the return value from `f()`? — moooeeeep, Dec 30 '13 at 10:41
@moooeeeep Because it's not a candidate for copy elision. NRVO doesn't happen for objects that are function parameters. — Joseph Mansfield, Dec 30 '13 at 10:43
@moooeeeep There's [a question about this](http://stackoverflow.com/q/6009278/150634), and it's not really a simple answer. — Joseph Mansfield, Dec 30 '13 at 10:47
@moooeeeep I also found [the issue that changed this](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3222.html#1148), but it doesn't really give any rationale. — Joseph Mansfield, Dec 30 '13 at 11:04

score 6 · Accepted Answer · answered Dec 30 '13 at 10:32

The compiler optimizes away the return copy. This is known as NRVO (Named Return Value Optimization).

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

The compiler is allowed to do this, even if the copy constructor has side effects.

When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the copy/move constructor and/or destructor for the object have side effects.

That is, if you give your copy/move constructors side effects, your program has multiple valid execution paths, depending on whether your compiler wants to optimize or not.

Still have question: why this kind of optimization is not applied to the argument of `f()`? — zeno tsang, Dec 30 '13 at 10:41
@zenotsang Because the standard specifically says that it doesn't apply to function parameters: "(other than a function or catch-clause parameter)" — Joseph Mansfield, Dec 30 '13 at 10:45

Why isn't the copy-constructor called when returning LOCAL variable

1 Answers1

Linked

Related