Why do std::shared_ptr work

by

The trick is that std::shared_ptr performs type erasure. Basically, when a new shared_ptr is created it will store internally a deleter function (which can be given as argument to the constructor but if not present defaults to calling delete). When the shared_ptr is destroyed, it calls that stored function and that will call the deleter.

A simple sketch of the type erasure that is going on simplified with std::function, and avoiding all reference counting and other issues can be seen here:

template <typename T>
void delete_deleter( void * p ) {
   delete static_cast<T*>(p);
}

template <typename T>
class my_unique_ptr {
  std::function< void (void*) > deleter;
  T * p;
  template <typename U>
  my_unique_ptr( U * p, std::function< void(void*) > deleter = &delete_deleter<U> ) 
     : p(p), deleter(deleter) 
  {}
  ~my_unique_ptr() {
     deleter( p );   
  }
};

int main() {
   my_unique_ptr<void> p( new double ); // deleter == &delete_deleter<double>
}
// ~my_unique_ptr calls delete_deleter<double>(p)

When a shared_ptr is copied (or default constructed) from another the deleter is passed around, so that when you construct a shared_ptr<T> from a shared_ptr<U> the information on what destructor to call is also passed around in the deleter.

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. Should we pass a shared_ptr by reference or by value?
  7. Passing shared pointers as arguments
  8. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  9. Passing shared_ptr as shared_ptr
  10. Where is shared_ptr?
  11. std::shared_ptr thread safety explained
  12. Should I use shared_ptr or unique_ptr
  13. What is the difference between an empty and a null std::shared_ptr in C++?
  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. When should I use std::thread::detach?
  21. Resolving ambiguous overload on function pointer and std::function for a lambda using + (unary plus)
  22. regex replace with callback in c++11?
  23. Writing Universal memoization function in C++11
  24. How would you implement your own reader/writer lock in C++11?
  25. Expansion with variadic templates [duplicate]
  26. C function pointers with C++11 lambdas
  27. Using shared_ptr in dll-interfaces
  28. Which greedy initializer-list examples are lurking in the Standard Library?
  29. Undefined reference to process(std::__cxx11::basic_string … ) when compiling affdex linux sample applications
  30. C++ view types: pass by const& or by value?

Leave a Comment