weak_ptr, make_shared and memory deallocation

by

Is my understanding correct?

Yes. If your weak_ptrs significantly outlive the (large) object and you are tight on memory, it may be beneficial to avoid make_shared.

However, “large” here is measured by sizeof, and many conceptually “large” objects (for example, most standard containers, except std::array) are quite small by that metric, because they allocate additional memory to store their contents, which will be freed as soon as the object is destroyed.

More Related Contents:

  1. shared_ptr and weak_ptr differences
  2. How do I call ::std::make_shared on a class with only protected or private constructors?
  3. shared_ptr to an array : should it be used?
  4. Difference in make_shared and normal shared_ptr in C++
  5. Differences between unique_ptr and shared_ptr [duplicate]
  6. Why isn’t there a std::shared_ptr specialisation?
  7. Why do std::shared_ptr work
  8. Should we pass a shared_ptr by reference or by value?
  9. Passing shared pointers as arguments
  10. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  11. Passing shared_ptr as shared_ptr
  12. Where is shared_ptr?
  13. std::shared_ptr thread safety explained
  14. Should I use shared_ptr or unique_ptr
  15. What is the difference between an empty and a null std::shared_ptr in C++?
  16. Is make_shared really more efficient than new?
  17. How do shared pointers work?
  18. Why would I std::move an std::shared_ptr?
  19. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  20. What is the cyclic dependency issue with shared_ptr?
  21. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  22. About thread-safety of weak_ptr
  23. Error while passing vector to instance of object in main
  24. Concurrency: Atomic and volatile in C++11 memory model
  25. The new syntax “= default” in C++11
  26. When is std::weak_ptr useful?
  27. Exception safety and make_unique
  28. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  29. std::pow produce different result in 32 bit and 64 bit application
  30. Why is this C++ wrapper class not being inlined away?

Leave a Comment