std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]

by

Both examples are rather more verbose than necessary:

std::shared_ptr<int> p(new int);  // or '=shared_ptr<int>(new int)' if you insist
auto p = std::make_shared<int>(); // or 'std::shared_ptr<int> p' if you insist

What’s the difference?

The main difference is that the first requires two memory allocations: one for the managed object (new int), and one for the reference count. make_shared should allocate a single block of memory, and create both in that.

Which one should I prefer and why?

You should usually use make_shared as it’s more efficient. As noted in another answer, it also avoids any possibility of a memory leak, since you never have a raw pointer to the managed object.

However, as noted in the comments, it has a potential disadvantage that the memory won’t be released when the object is destroyed, if there are still weak pointers preventing the shared count from being deleted.

EDIT 2020/03/06:

Further recommendations come also from the official Microsoft documentation with associated examples. Keep the focus on the Example 1 snippet:

Whenever possible, use the make_shared function to create a shared_ptr
when the memory resource is created for the first time. make_shared is
exception-safe. It uses the same call to allocate the memory for the
control block and the resource, which reduces the construction
overhead. If you don’t use make_shared, then you have to use an
explicit new expression to create the object before you pass it to the
shared_ptr constructor. The following example shows various ways to
declare and initialize a shared_ptr together with a new object.

More Related Contents:

  1. Passing shared_ptr as shared_ptr
  2. Where is shared_ptr?
  3. Why would I std::move an std::shared_ptr?
  4. What is a smart pointer and when should I use one?
  5. Which kind of pointer do I use when?
  6. How do I call ::std::make_shared on a class with only protected or private constructors?
  7. Why can I not push_back a unique_ptr into a vector?
  8. shared_ptr to an array : should it be used?
  9. Difference in make_shared and normal shared_ptr in C++
  10. Differences between std::make_unique and std::unique_ptr with new
  11. Is there any use for unique_ptr with array?
  12. “Downcasting” unique_ptr to unique_ptr
  13. Why isn’t there a std::shared_ptr specialisation?
  14. Should we pass a shared_ptr by reference or by value?
  15. How much is the overhead of smart pointers compared to normal pointers in C++?
  16. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  17. smart pointers and arrays
  18. Passing shared pointers as arguments
  19. Should I delete the move constructor and the move assignment of a smart pointer?
  20. std::shared_ptr thread safety explained
  21. std::auto_ptr to std::unique_ptr
  22. Why is auto_ptr being deprecated?
  23. What is the difference between an empty and a null std::shared_ptr in C++?
  24. How do shared pointers work?
  25. shared_ptr and weak_ptr differences
  26. Example to use shared_ptr?
  27. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  28. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  29. weak_ptr, make_shared and memory deallocation
  30. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?

Leave a Comment