Passing smart pointers is an important topic which is seldom addressed. This ends with the C++ core guidelines because they have six rules for passing std::shared_ptr and std::unique_ptr.

The six rules violate the import dry (don't repeat yourself) principle for software development. At the end, we have only four rules what makes our life as a software developer a lot easier. Here are the rules.
Let's start with the first two rules for std::unique_ptr.
If a function should take ownership of a Widget, you should take the std::unique_ptr<Widget> by copy. The consequence is that the caller has to move the std::unique_ptr<Widget> to make the code to run.
#include <memory>
#include <utility>
struct Widget{
Widget(int){}
};
void sink(std::unique_ptr<Widget> uniqPtr){
// do something with uniqPtr
}
int main(){
auto uniqPtr = std::make_unique<Widget>(1998);
sink(std::move(uniqPtr)); // (1)
sink(uniqPtr); // (2) ERROR
}
The call (1) is fine but the call (2) breaks because you can not copy an std::unique_ptr. If your function only wants to use the Widget, it should take its parameter by pointer of by reference. The difference between a pointer and a reference is that a pointer can be a null pointer.
void useWidget(Widget* wid);
void useWidget(Widget& wid);
Sometimes a function want's to reseat a Widget. In this use-case, you should pass the std::unique_ptr<Widget> by a non-const reference.
#include <memory>
#include <utility>
struct Widget{
Widget(int){}
};
void reseat(std::unique_ptr<Widget>& uniqPtr){
uniqPtr.reset(new Widget(2003)); // (0)
// do something with uniqPtr
}
int main(){
auto uniqPtr = std::make_unique<Widget>(1998);
reseat(std::move(uniqPtr)); // (1) ERROR
reseat(uniqPtr); // (2)
}
Now, the call (1) fails because you can not bind an rvalue to a non-const lvalue reference. This will not hold for the copy in (2). A lvalue can be bound to an lvalue reference. By the way. The call (0) will not only construct a new Widget(2003), it will also destruct the old Widget(1998).
The next three rules to std::shared_ptr are literally repetitions; therefore, I will make one out of them.
Here are the three function signatures, we have to deal with.
void share(std::shared_ptr<Widget> shaWid);
void reseat(std::shard_ptr<Widget>& shadWid);
void mayShare(const std::shared_ptr<Widget>& shaWid);
Let's look at each function signature in isolation. What does this mean from the function perspective?
- void share(std::shared_ptr<Widget> shaWid): I'm for the lifetime of the function body a shared owner of the Widget. At the begin of the function body, I will increase the reference counter; at the end of the function, I will decrease the reference counter; therefore, the Widget will stay alive, as long as I use it.
- void reseat(std::shared_ptr<Widget>& shaWid): I'm not a shared owner of the Widget, because I will not change the reference counter. I have not guaranteed that the Widget will stay alive during the execution of my function, but I can reseat the resource. A non-const lvalue reference is more like: I borrow the resource and can reseat it.
- void mayShare(const std::shared_ptr<Widget>& shaWid): I only borrow the resource. Either can I extend the lifetime of the resource nor can I reseat the resource. To be honest, you should use a pointer (Widget*) or a reference (Widget&) as a parameter instead, because there is no added value in using a std::shared_ptr.
Let me present you a short code snippet to make the rule clear.
void oldFunc(Widget* wid){
// do something with wid
}
void shared(std::shared_ptr<Widget>& shaPtr){ // (2)
oldFunc(*shaPtr); // (3)
// do something with shaPtr
}
auto globShared = std::make_shared<Widget>(2011); // (1)
...
shared(globShared);
globShared (1) is a globally shared pointer. The function shared takes it argument per reference (2). Therefore, the reference counter of shaPtr will no be increased and the function share will no extend the lifetime of Widget(2011). The issue begins with (3). oldFunc accepts a pointer to the Widget; therefore, oldFunc has no guarantee that the Widget will stay alive during its execution. oldFunc only borrows the Widget.
The cure is quite simple. You have to ensure that the reference count of globShared will be increased before the call to the function oldFunc. This means you have to make a copy of the std::shared_ptr:
- Pass the std::shared_ptr by copy to the function shared:
void shared(std::shared_ptr<Widget> shaPtr){
oldFunc(*shaPtr);
// do something with shaPtr
}
- Make a copy of the shaPtr in the function shared:
void shared(std::shared_ptr<Widget>& shaPtr){
auto keepAlive = shaPtr;
oldFunc(*shaPtr);
// do something with keepAlive or shaPtr
}
The same reasoning also applies to std::unique_ptr but I have no simple cure in mind because you can not copy an std::unique_ptr. I suggest you should clone your std::unique_ptr and, therefore, make a new std::unique_ptr.
What's next?
This was the last of my four posts about resource management in the C++ core guidelines. The C++ core guidelines has more than 50 rules for expressions and statements. I will have a closer look at my next post.
Thanks a lot to my Patreon Supporters: Matt Braun, Roman Postanciuc, Tobias Zindl, Marko, G Prvulovic, Reinhold Dröge, Abernitzke, Frank Grimm, Sakib, Broeserl, António Pina, Darshan Mody, Sergey Agafyin, Андрей Бурмистров, Jake, GS, Lawton Shoemake, Animus24, Jozo Leko, John Breland, espkk, Wolfgang Gärtner, Louis St-Amour, Stephan Roslen, Venkat Nandam, Jose Francisco, Douglas Tinkham, Kuchlong Kuchlong, Avi Kohn, Robert Blanch, Truels Wissneth, Kris Kafka, Mario Luoni, Neil Wang, Friedrich Huber, lennonli, Pramod Tikare Muralidhara, Peter Ware, and Tobi Heideman.
Thanks in particular to Jon Hess, Lakshman, Christian Wittenhorst, Sherhy Pyton, Dendi Suhubdy, Sudhakar Belagurusamy, and Richard Sargeant.
My special thanks to Embarcadero 
Seminars
I'm happy to give online-seminars or face-to-face seminars world-wide. Please call me if you have any questions.
Bookable (Online)
Deutsch
English
Standard Seminars
Here is a compilation of my standard seminars. These seminars are only meant to give you a first orientation.
New
Contact Me
Modernes C++,

Comments
We should whether change the oldFunc as:
void oldFunc(const Widget& wid),
or change the oldFunc call as:
oldFunc(shaPtr.get());
The function shared is holding onto the shared_ptr reference which means the ref-counter won't drop to zero.
if the ref-count may drop to zero from a different thread, it can happen before the copy and you have much tougher problems.
There is no 39 on this page. What should I fix?
IOW: In the R37 listing, the reference count for globShared is initialized to 1 when it's first constructed at (1). So, when shared(globShared) is called on the very last line, the reference count will STILL be (at least) 1. And since the execution of that block of code will be suspended until shared() returns, there's no real way the count can drop BELOW 1 during the execution of shared() and oldFunc(), since the original globShared reference can't possibly be destroyed until after shared() returns and the code that called it resumes... no?
std::shared_ptr && widget
Thanks.
RSS feed for comments to this post