Differences between std::make_unique and std::unique_ptr with new
c++, c++11, c++14, smart-pointers, unique-ptr
Solution
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.
Problem
Does `std::make_unique` have any efficiency benefits like `std::make_shared`? Compared to manually constructing `std::unique_ptr`: ``` std::make_unique<int>(1); // vs std::unique_ptr<int>(new int(1)); ```