What is the difference between an empty and a null std::shared_ptr in C++?

by

It’s a weird corner of shared_ptr behavior. It has a constructor that allows you to make a shared_ptr that owns something and points to something else:

template< class Y > 
shared_ptr( const shared_ptr<Y>& r, T *ptr );

The shared_ptr constructed using this constructor shares ownership with r, but points to whatever ptr points to (i.e., calling get() or operator->() will return ptr). This is handy for cases where ptr points to a subobject (e.g., a data member) of the object owned by r.

The page you linked calls a shared_ptr that owns nothing empty, and a shared_ptr that points to nothing (i.e., whose get() == nullptr) null. (Empty is used in this sense by the standard; null isn’t.) You can construct a null-but-not-empty shared_ptr, but it won’t be very useful. An empty-but-not-null shared_ptr is essentially a non-owning pointer, which can be used to do some weird things like passing a pointer to something allocated on the stack to a function expecting a shared_ptr (but I’d suggest punching whoever put shared_ptr inside the API first).

boost::shared_ptr also has this constructor, which they call the aliasing constructor.

More Related Contents:

  1. How do I call ::std::make_shared on a class with only protected or private constructors?
  2. shared_ptr to an array : should it be used?
  3. Difference in make_shared and normal shared_ptr in C++
  4. Differences between unique_ptr and shared_ptr [duplicate]
  5. Why isn’t there a std::shared_ptr specialisation?
  6. Why do std::shared_ptr work
  7. Should we pass a shared_ptr by reference or by value?
  8. Passing shared pointers as arguments
  9. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  10. Passing shared_ptr as shared_ptr
  11. Where is shared_ptr?
  12. std::shared_ptr thread safety explained
  13. Should I use shared_ptr or unique_ptr
  14. How do shared pointers work?
  15. Why would I std::move an std::shared_ptr?
  16. shared_ptr and weak_ptr differences
  17. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  18. weak_ptr, make_shared and memory deallocation
  19. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  20. What are Aggregates and PODs and how/why are they special?
  21. C++11 does not deduce type when std::function or lambda functions are involved
  22. Why is `std::move` named `std::move`?
  23. How to check if a std::thread is still running?
  24. What exactly is std::atomic?
  25. Outputting Date and Time in C++ using std::chrono
  26. What’s a use case for overloading member functions on reference qualifiers?
  27. Setting vector elements in range-based for loop [duplicate]
  28. Can the point-of-instantiation be delayed until the end of the translation unit?
  29. How to create timer events using C++ 11?
  30. How to pass a template function in a template argument list

Leave a Comment