If you're going to pass it by const_ref, why not just pass the actual stored object by const_ref instead?
>> That's a good point. If the function will eventually lead to some object retaining a reference, then you should use a non-const shared_ptr ref. The assignment into the object will do the copy constructor and that needs a non-const ref. But, you don't need to be making temp object copies along the way. If the function will not lead to something retaining a reference, then you shouldn't be passing the reference retention object to it. Just pass a direct ref to the target object.
Hum? What assignment into the object? Where I'd typically see taking a `const std::shared_ptr<> &` to signal "retaining ownership" would be something like this:
class Foo {
public:
void AppendChild(const std::shared_ptr<Foo> &x) {
children_.emplace_back(x);
}
private:
std::vector<std::shared_ptr<Foo>> children_;
};
This also gives callers the flexibility to std::move into your argument, transferring ownership.
A good rule of thumb is, if you are going to unconditionally take ownership of an object, accept it by value.