Exception safety and make_unique

by

Not only when you have multiple allocations, but whenever you can throw at different places. Consider this:

f(make_unique<T>(), function_that_can_throw());

Versus:

f(unique_ptr<T>(new T), function_that_can_throw());

In the second case, the compiler is allowed to call (in order):

  • new T
  • function_that_can_throw()
  • unique_ptr<T>(...)

Obviously if function_that_can_throw actually throws then you leak. make_unique prevents this case.

And of course, a second allocation (as in your question) is just a special case of function_that_can_throw().

As a general rule of thumb, just use make_unique so that your code is consistent. It is always correct (read: exception-safe) when you need a unique_ptr, and it doesn’t have any impact on performance, so there is no reason not to use it (while actually not using it introduces a lot of gotchas).

More Related Contents:

  1. Is std::unique_ptr required to know the full definition of T?
  2. Why can I not push_back a unique_ptr into a vector?
  3. make_unique and perfect forwarding
  4. How do I pass a unique_ptr argument to a constructor or a function?
  5. Differences between std::make_unique and std::unique_ptr with new
  6. How do I use a custom deleter with a std::unique_ptr member?
  7. Differences between unique_ptr and shared_ptr [duplicate]
  8. Is there any use for unique_ptr with array?
  9. “Downcasting” unique_ptr to unique_ptr
  10. Copy constructor for a class with unique_ptr
  11. How to implement make_unique function in C++11? [duplicate]
  12. The simplest and neatest c++11 ScopeGuard
  13. How do I use unique_ptr for pimpl?
  14. Proper way to create unique_ptr that holds an allocated array
  15. So can unique_ptr be used safely in stl collections?
  16. std::unique_ptr, deleters and the Win32 API
  17. std::auto_ptr to std::unique_ptr
  18. How does the custom deleter of std::unique_ptr work?
  19. Should I use shared_ptr or unique_ptr
  20. error::make_unique is not a member of ‘std’
  21. shared_ptr is to weak_ptr as unique_ptr is to… what?
  22. Raw pointer lookup for sets of unique_ptrs
  23. unique_ptr and OpenSSL’s STACK_OF(X509)*
  24. How can I compile C++11 code with Orwell Dev-C++?
  25. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  26. Should std::unique_ptr be permitted
  27. stl container with std::unique_ptr’s vs boost::ptr_container
  28. Is there a way to write make_unique() in VS2012?
  29. Does std::bind work with move-only types in general, and std::unique_ptr in particular?
  30. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?

Leave a Comment