shared_ptr by reference or by value?

Question

When a function should take a boost::shared_ptr, are you passing it

by const reference void foo(const boost::shared_ptr<T>& p)

or by value void foo(boost::shared_ptr<T> p) ?

I would prefer the first method because I suspect it to be faster. But is this really worth a though or are there any additional issues?

Edit: Could you please give the reasons for your choice or if the case, why you think that it does not matter.

Answer 1

Personally I would use a const reference. There is no need to increment the reference count just to decrement it again for the sake of a function call.

Answer 2

Pass by const reference, it's faster. If you need to store it, say in some container, the ref. count will be auto-magically incremented by the copy operation.

Answer 3

I'd pass it by reference, if only because of std::auto_ptr semantics:

When you do

void foo(std::auto_ptr<bar> p);

the behaviour is very different from

void foo(std::auto_ptr<char> const&p);

which is what you usually expect. Passing by reference is what the caller usually expects, passing by reference has a surprising behavior, and many people will fall in the trap.

As a rule, I always pass smart pointers by const reference.

Answer 4

shared_ptr isn't large enough, nor do its constructor\destructor do enough work for there to be enough overhead from the copy to care about pass by reference vs pass by copy performance.