Why does compiler use move constructor instead of the copy constructor

Question

Is it ok that the following code

#include <iostream>

struct Foo
{
    Foo() { std::cout << "Foo::Foo" << std::endl; }
    ~Foo() { std::cout << "Foo::~Foo" << std::endl; }

    Foo(const Foo&) { std::cout << "Foo::Foo(const Foo&)" << std::endl; }
    Foo& operator=(const Foo&) { std::cout << "Foo::operator=(const Foo&)" << std::endl; return *this; }

    Foo(Foo&&) { std::cout << "Foo::Foo(Foo&&)" << std::endl; }
    Foo& operator=(Foo&&) { std::cout << "Foo::operator=(Foo&&)" << std::endl; return *this; }
};

Foo foo()
{
    Foo second;
    return second;
}

int main()
{
    foo();
}

produces such output:

Foo::Foo
Foo::Foo(Foo&&)
Foo::~Foo
Foo::~Foo

Why does it call move constructor instead of the copy constructor?

I suspect that optimisation is turned off in your settings when you compile because I would expect move constructor and one of destructor calls to be optimised away due to RVO. — Dev Null
– Dev Null, Commented Aug 11, 2017 at 1:51

Nir Friedman · Accepted Answer · 2017-08-11 03:28:44Z

3

The answer is simply because the standard says so. Section 12.8, paragraph 32:

When the criteria for elision of a copy/move operation are met, but not for an exception-declaration, and the object to be copied is designated by an lvalue, or when the expression in a return statement is a (possibly parenthesized) id-expression that names an object with automatic storage duration declared in the body or parameter-declaration-clause of the innermost enclosing function or lambda-expression, overload resolution to select the constructor for the copy is first performed as if the object were designated by an rvalue.

And that's basically all there is to it. Logically, if the variable has automatic storage duration, and you return it, then immediately after the return, the variable will not exist any more when the local scope cleans up. That is why, even though it is an lvalue, it is quite similar to an rvalue. Because it's still technically an lvalue, this exception has to be made explicitly in the standard, and here we are. Note that this whole situation is specific to returning from a function, and does not include scope ending in general.

answered Aug 11, 2017 at 3:28

Nir Friedman

17.9k2 gold badges48 silver badges77 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

juanchopanza Over a year ago

The standard also says the return is a candidate for copy elision. It is very strange that RVO doesn't take place here.

Dev Null · Accepted Answer · 2017-08-11 03:40:55Z

2

second is returned from foo, and, being a local object, is treated as an rvalue (thanks to Nir Friedman for the correct explanation). The returned Foo object is constructed from a temporary, which binds to the move constructor.

Modern compiler should skip the move constructor call and use copy elision (demo).

edited Aug 11, 2017 at 3:40

answered Aug 11, 2017 at 1:38

Dev Null

5,1071 gold badge34 silver badges49 bronze badges

6 Comments

FrozenHeart Over a year ago

Why does it created from a temporary? I thought that the second is an l-value here

Dev Null Over a year ago

because second goes out of scope and can't be assigned (i.e. be at the left side of =) anymore.

FrozenHeart Over a year ago

But it is still in the scope during the return statement, isn't it?

Dev Null Over a year ago

yes, but after return it's no longer in scope, a Foo object in scope of main is created from a temporary object that is no longer in scope as foo has finished.

FrozenHeart Over a year ago

Ok, I see. Thanks

|

Collectives™ on Stack Overflow

Why does compiler use move constructor instead of the copy constructor

2 Answers 2

1 Comment

6 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

6 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related