Passing shared pointers as arguments

by

I want to pass a shared pointer to a function. Can you help me with that?

Sure, I can help with you that. I assume you have some understanding of ownership semantics in C++. Is that true?

Yeah, I’m reasonably comfortable with the subject.

Good.

Ok, I can only think of two reasons to take a shared_ptr argument:

  1. The function wants to share ownership of the object;
  2. The function does some operation that works specifically on shared_ptrs.

Which one are you interested in?

I’m looking for a general answer, so I’m actually interested in both. I’m curious about what you mean in case #2, though.

Examples of such functions include std::static_pointer_cast, custom comparators, or predicates. For example, if you need to find all unique shared_ptr from a vector, you need such a predicate.

Ah, when the function actually needs to manipulate the smart pointer itself.

Exactly.

In that case, I think we should pass by reference.

Yes. And if it doesn’t change the pointer, you want to pass by const reference. There’s no need to copy since you don’t need to share ownership. That’s the other scenario.

Ok, got it. Let’s talk about the other scenario.

The one where you share the ownership? Ok. How do you share ownership with shared_ptr?

By copying it.

Then the function will need to make a copy of a shared_ptr, correct?

Obviously. So I pass it by a reference to const and copy to a local variable?

No, that’s a pessimization. If it is passed by reference, the function will have no choice but to make the copy manually. If it is passed by value the compiler will pick the best choice between a copy and a move and perform it automatically. So, pass by value.

Good point. I must remember that “Want Speed? Pass by Value.” article more often.

Wait, what if the function stores the shared_ptr in a member variable, for example? Won’t that make a redundant copy?

The function can simply move the shared_ptr argument into its storage. Moving a shared_ptr is cheap because it doesn’t change any reference counts.

Ah, good idea.

But I’m thinking of a third scenario: what if you don’t want to manipulate the shared_ptr, nor to share ownership?

In that case, shared_ptr is completely irrelevant to the function. If you want to manipulate the pointee, take a pointee, and let the callers pick what ownership semantics they want.

And should I take the pointee by reference or by value?

The usual rules apply. Smart pointers don’t change anything.

Pass by value if I’m going to copy, pass by reference if I want to avoid a copy.

Right.

Hmm. I think you forgot yet another scenario. What if I want to share ownership, but only depending on a certain condition?

Ah, an interesting edge case. I don’t expect that to happen often. But when it happens you can either pass by value and ignore the copy if you don’t need it, or pass by reference and make the copy if you need it.

I risk one redundant copy in the first option, and lose a potential move in the second. Can’t I eat the cake and have it too?

If you’re in a situation where that really matters, you can provide two overloads, one taking a const lvalue reference, and another taking an rvalue reference. One copies, the other moves. A perfect-forwarding function template is another option.

I think that covers all the possible scenarios. Thank you very much.

More Related Contents:

  1. What is a smart pointer and when should I use one?
  2. What is move semantics?
  3. What are rvalues, lvalues, xvalues, glvalues, and prvalues?
  4. What are the main purposes of using std::forward and which problems it solves?
  5. What does T&& (double ampersand) mean in C++11?
  6. Which kind of pointer do I use when?
  7. What is std::move(), and when should it be used?
  8. How do I call ::std::make_shared on a class with only protected or private constructors?
  9. shared_ptr to an array : should it be used?
  10. Difference in make_shared and normal shared_ptr in C++
  11. Does const mean thread-safe in C++11?
  12. Differences between unique_ptr and shared_ptr [duplicate]
  13. Why isn’t there a std::shared_ptr specialisation?
  14. Why do std::shared_ptr work
  15. What are the advantages of using nullptr?
  16. Is the ‘override’ keyword just a check for a overridden virtual method?
  17. Should we pass a shared_ptr by reference or by value?
  18. Passing shared_ptr as shared_ptr
  19. std::shared_ptr thread safety explained
  20. When do extra parentheses have an effect, other than on operator precedence?
  21. Should I use shared_ptr or unique_ptr
  22. What is the difference between an empty and a null std::shared_ptr in C++?
  23. shared_from_this causing bad_weak_ptr
  24. How do shared pointers work?
  25. Why would I std::move an std::shared_ptr?
  26. shared_ptr and weak_ptr differences
  27. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  28. weak_ptr, make_shared and memory deallocation
  29. What is std::move(), and when should it be used and does it actually move anything?
  30. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?

Leave a Comment