std::make_unique vs new Keyword

std::make_unique, introduced in C++14, is generally preferred over using the new keyword directly when creating a std::unique_ptr. Here are several reasons why:

Exception Safety

If you use new and then pass the raw pointer to the unique_ptr constructor, there's a risk of a memory leak if an exception is thrown before the unique_ptr takes ownership. std::make_unique avoids this by constructing the object directly in the unique_ptr.

Consider this example:

1#include <memory>
2#include <iostream>
3
4void SomeFunction() {
5  std::unique_ptr<int> p{new int{0}};
6  throw std::exception{};  
7}
8
9int main() {
10  try {
11    SomeFunction();
12  } catch (...) {
13    std::cout << "Caught exception, but "
14      "possibly leaked memory";
15  }
16}

1Caught exception, but possibly leaked memory

If an exception is thrown after the new int{0} but before the unique_ptr constructor, the memory will leak. Now consider the same example with make_unique:

1#include <memory>
2#include <iostream>
3
4void SomeFunction() {
5  std::unique_ptr<int> p{
6    std::make_unique<int>(0)};
7  throw std::exception{};
8}
9
10int main() {
11  try {
12    SomeFunction();
13  } catch (...) {
14    std::cout << "Caught exception, "
15      "without leaking memory";
16  }
17}

1Caught exception, without leaking memory

Here, if an exception is thrown, the unique_ptr will still properly clean up the memory.

Readability

std::make_unique makes it clear that the intent is to create a unique_ptr. It's a more expressive way to create a smart pointer.

Consistency

std::make_unique provides consistency with std::make_shared, which is the recommended way to create a std::shared_ptr.

Less typing

While not a major advantage, std::make_unique does save you from typing out the template argument twice:

1// With new
2std::unique_ptr<Character> Gandalf{
3  new Character{"Gandalf"}};
4
5// With make_unique
6auto Gandalf{std::make_unique<Character>(
7  "Gandalf")};

There are a few situations where you might still use new with unique_ptr:

• If you need to specify a custom deleter
• If you're working with C++11 (although you can implement your own make_unique for C++11)

But in most cases, std::make_unique is the preferred way to create a std::unique_ptr.