C++11 move to local const reference: scope

Question

For regular local const reference variables, the scope is prolonged. Which is why the following code works as expected:

#include <iostream>
#include <memory>

struct foo
{
        foo()
        {
                std::cout << "foo() @" << (void*)this << std::endl;
        }
        ~foo()
        {
                std::cout << "~foo() @" << (void*)this << std::endl;
        }
};

int main()
{
        auto const& f = std::make_shared<foo>();
        std::cout << "f = " << f.get() << std::endl;
        return 0;
}

// prints:
// foo() @0x55f249c58e80
// f = 0x55f249c58e80
// ~foo() @0x55f249c58e80

It seems though that this does not work as expected when assigning a moved object using std::move():

#include <iostream>
#include <memory>
#include <list>

struct foo
{
        foo()
        {
                std::cout << "foo() @" << (void*)this << std::endl;
        }
        ~foo()
        {
                std::cout << "~foo() @" << (void*)this << std::endl;
        }
};

int main()
{
        std::list<std::shared_ptr<foo>> l;
        l.push_back(std::make_shared<foo>());
        auto const& f = std::move(l.front());
        l.clear();
        std::cout << "f = " << f.get() << std::endl;
        return 0;
}

// prints
// foo() @0x564edb58fe80
// ~foo() @0x564edb58fe80
// f = 0x564edb58fe80

Does std::move() indeed change the scope, or am I dealing with a compiler bug?

Changing the variable from auto const& f to just auto f fixes the problem. If I wrap the move into another function, it also works:

auto const& f = [&]() { return std::move(l.front()); }();

It's almost like std::move() does not share the same semantics as a function call, but rather as if it was just a regular variable assignment:

auto const& f = std::move(l.front());

Answer 1

Let's put aside std::move() and create this function:

struct sometype {};

const sometype &foobar( const sometype &cref ) { return cref; }

and now we use it:

const sometype &ref = foobar( sometype() );

What do you think, will lifetime of temporary be prolongated in this case? No it would not. Lifetime is only prolongated when you assign to a reference directly. When it goes through a function or through static_cast or std::move that prolongation is gone. So you have exactly the same issue with std::move()

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

const sometype &foobar( const sometype &cref ) { return cref; }

int main()
{
    const sometype &cref1 = foobar( sometype() );
    sometype &&cref2 = std::move( sometype() );
    std::cout << "main continues" << std::endl;
}

output:

ctype()
~ctype()
ctype()
~ctype()
main continues     

live example

Note: you should not use std::move() on return statement, it does not give you anything.

For your code change. You should remember that std::move() does not move anything. It is done by special assignment operator or constructor (if they provided for a type). So when you write this code:

const type &ref = std::move( something );

there is no constructor nor assignment operator involved and so no moving happens. For actual moving to happen you have to assign it to a variable:

type val = std::move( something );

now moving would happen if possible or copy otherwise.