Differences between std::make_unique and std::unique_ptr with new

by

The motivation behind make_unique is primarily two-fold:

  • make_unique is safe for creating temporaries, whereas with explicit use of new you have to remember the rule about not using unnamed temporaries.

    foo(make_unique<T>(), make_unique<U>()); // exception safe

foo(unique_ptr<T>(new T()), unique_ptr<U>(new U())); // unsafe*

  • The addition of make_unique finally means we can tell people to ‘never’ use new rather than the previous rule to “‘never’ use new except when you make a unique_ptr“.

There’s also a third reason:

  • make_unique does not require redundant type usage. unique_ptr<T>(new T()) -> make_unique<T>()

None of the reasons involve improving runtime efficiency the way using make_shared does (due to avoiding a second allocation, at the cost of potentially higher peak memory usage).

* It is expected that C++17 will include a rule change that means that this is no longer unsafe. See C++ committee papers P0400R0 and P0145R3.

More Related Contents:

  1. Why can I not push_back a unique_ptr into a vector?
  2. Is there any use for unique_ptr with array?
  3. “Downcasting” unique_ptr to unique_ptr
  4. How to implement make_unique function in C++11? [duplicate]
  5. std::auto_ptr to std::unique_ptr
  6. error::make_unique is not a member of ‘std’
  7. Raw pointer lookup for sets of unique_ptrs
  8. unique_ptr and OpenSSL’s STACK_OF(X509)*
  9. make_unique and perfect forwarding
  10. Differences between unique_ptr and shared_ptr [duplicate]
  11. Overload resolution between object, rvalue reference, const reference
  12. Pointers in c++ after delete
  13. C++11: Correct std::array initialization?
  14. Pass by value vs pass by rvalue reference
  15. How do I use unique_ptr for pimpl?
  16. Default, value and zero initialization mess
  17. Is #pragma once part of the C++11 standard?
  18. Exception safety and make_unique
  19. Are notes and examples in the core language specification of the C++ Standard non-normative?
  20. Passing shared_ptr as shared_ptr
  21. Check traits for all variadic template arguments
  22. Calling initializer_list constructor via make_unique/make_shared
  23. Should I use shared_ptr or unique_ptr
  24. How to immediately invoke a C++ lambda?
  25. Is auto_ptr deprecated?
  26. How can I compile C++11 code with Orwell Dev-C++?
  27. Why would I std::move an std::shared_ptr?
  28. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  29. Why is `make_unique` disallowed?
  30. Is there a way to write make_unique() in VS2012?

Leave a Comment