Should we pass a shared ptr by reference or by value

Question

When a function takes a shared ptr  from boost or C  11 STL   are you passing it    by const reference  void foo const shared ptr lt T gt  amp  p  or by value  void foo shared ptr lt T gt  p      I would prefer the first method because I suspect it would be faster  But is this really worth it or are there any additional issues   Could you please give the reasons for your choice or if the case  why you think it does not matter

User · Accepted Answer

This question has been discussed and answered by Scott, Andrei and Herb during Ask Us Anything session at C++ and Beyond 2011. Watch from 4:34 on shared_ptr performance and correctness.

Shortly, there is no reason to pass by value, unless the goal is to share ownership of an object (eg. between different data structures, or between different threads).

Unless you can move-optimise it as explained by Scott Meyers in the talk video linked above, but that is related to actual version of C++ you can use.

A major update to this discussion has happened during GoingNative 2012 conference's Interactive Panel: Ask Us Anything! which is worth watching, especially from 22:50.

User · Answer

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

User · Answer

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

User · Answer

It s known issue that passing shared ptr by value has a cost and should be avoided  if possible   The cost of passing by shared ptr  Most of the time passing shared ptr by reference  and even better by const reference  would do   The cpp core guideline has a specific rule for passing shared ptr  R 34  Take a shared ptr parameter to express that a function is part owner  void share shared ptr lt widget gt                  share --  will  retain refcount   An example of when passing shared ptr by value is really necessary is when the caller passes a shared object to an asynchronous callee - ie the caller goes out of scope before the callee completes its job  The callee must  extend  the lifetime of the shared object by taking a share ptr by value  In this case  passing a reference to shared ptr won t do   The same goes for passing a shared object to a work thread

User · Answer

Here s Herb Sutter s take     Guideline  Don   t pass a smart pointer as a function parameter unless   you want to use or manipulate the smart pointer itself  such as to   share or transfer ownership       Guideline  Express that a function will store and share ownership of a   heap object using a by-value shared ptr parameter        Guideline  Use a   non-const shared ptr amp  parameter only to modify the shared ptr  Use a   const shared ptr amp  as a parameter only if you   re not sure whether or   not you   ll take a copy and share ownership  otherwise use widget    instead  or if not nullable  a widget amp

User · Answer

There was a recent blog post  https   medium com  vgasparyan1995 pass-by-value-vs-pass-by-reference-to-const-c-f8944171e3ce  So the answer to this is  Do  almost  never pass by const shared ptr lt T gt  amp   Simply pass the underlying class instead   Basically the only reasonable parameters types are    shared ptr lt T gt  - Modify and take ownership shared ptr lt const T gt  - Don t modify  take ownership T amp  - Modify  no ownership const T amp  - Don t modify  no ownership T - Don t modify  no ownership  Cheap to copy   As  accel pointed out in https   stackoverflow com a 26197326 1930508 the advice from Herb Sutter is      Use a const shared ptr amp  as a parameter only if you   re not sure whether or not you   ll take a copy and share ownership   But in how many cases are you not sure  So this is a rare situation

User · Answer

I ran the code below  once with foo taking the shared ptr by const amp  and again with foo taking the shared ptr by value   void foo const std  shared ptr lt int gt  amp  p        static int x   0       p     x     int main         auto p   std  make shared lt int gt         auto start   clock        for  int i   0  i  lt  10000000    i                foo p                 std  cout  lt  lt   Took    lt  lt  clock   - start  lt  lt    ms   lt  lt  std  endl      Using VS2015  x86 release build  on my intel core 2 quad  2 4GHz  processor  const shared ptr amp      - 10ms   shared ptr            - 281ms    The copy by value version was an order of magnitude slower  If you are calling a function synchronously from the current thread  prefer the const amp  version

User · Answer

Not knowing time cost of shared copy copy operation where atomic increment and decrement is in  I suffered from much higher CPU usage problem  I never expected atomic increment and decrement may take so much cost   Following my test result  int32 atomic increment and decrement takes 2 or 40 times than non-atomic increment and decrement  I got it on 3GHz Core i7 with Windows 8 1  The former result comes out when no contention occurs  the latter when high possibility of contention occurs  I keep in mind that atomic operations are at last hardware based lock  Lock is lock  Bad to performance when contention occurs   Experiencing this  I always use byref const shared ptr amp   than byval shared ptr

User · Answer

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

User · Answer

Since C  11 you should take it by value over const amp  more often than you might think   If you are taking the std  shared ptr  rather than the underlying type T   then you are doing so because you want to do something with it   If you would like to copy it somewhere  it makes more sense to take it by copy  and std  move it internally  rather than taking it by const amp  and then later copying it  This is because you allow the caller the option to in turn std  move the shared ptr when calling your function  thus saving yourself a set of increment and decrement operations  Or not  That is  the caller of the function can decide whether or not he needs the std  shared ptr around after calling the function  and depending on whether or not move or not  This is not achievable if you pass by const amp   and thus it is then preferably to take it by value   Of course  if the caller both needs his shared ptr around for longer  thus can not std  move it  and you don t want to create a plain copy in the function  say you want a weak pointer  or you only sometimes want to copy it  depending on some condition   then a const amp  might still be preferable   For example  you should do  void enqueue std  shared lt T gt  t  m internal queue enqueue std  move t      over  void enqueue std  shared lt T gt  const amp  t  m internal queue enqueue t     Because in this case you always create a copy internally

[c++] Should we pass a shared_ptr by reference or by value?

Examples related to c++

Examples related to c++11

Examples related to boost

Examples related to shared-ptr