常量正确性，标准移动和智能指针

Question

I'm struggling to understand when should I use const smart pointers and when to move them.

Based on the following code:

class Foo;
class Bar;

typedef std::shared_ptr<Foo> FooPtr;
typedef std::shared_ptr<Bar> BarPtr;

class Bar {

};

class Foo {
public:
    static FooPtr create()
    {
        FooPtr f = std::make_shared<Foo>();
        f->initialize();
        return f;
    }

    void setData(const BarPtr& b) {
        m_b = b;
    }
private:
    BarPtr m_b;
};

inline const FooPtr& internalCreateFoo(const BarPtr& b)
{
    FooPtr foo = Foo::create();
    foo->setData(b);

    int id = foo->getID();
    m_foos[id] = std::move(foo);

    return m_foos[id];
}

1: is std::move(foo) really necessary here?

2: what happens regarding the std::move if foo is created as a const , like const FooPtr& foo = ... ?

Answer 1

is std::move(foo) really necessary here?

Necessary, no, useful, yes. Without the std::move foo is an lvalue so it will cause a copy. That can be inefficent. Since you don't need foo any longer, it makes sense to move it into the array instead of copying it.

what happens regarding the std::move if foo is created as a const , like const FooPtr& foo = ... ?

Then you would get a copy. You can't move something that is const since moving alters the state ¹ of the moved from object.

^{1: In theory a move might not need to alter the state of the moved from object, but then your just making a copy anyways.}