136

As far as I understand, C++14 introduced std::make_unique because, as a result of the parameter evaluation order not being specified, this was unsafe:

f(std::unique_ptr<MyClass>(new MyClass(param)), g()); // Syntax A

(Explanation: if the evaluation first allocates the memory for the raw pointer, then calls g() and an exception is thrown before the std::unique_ptr construction, then the memory is leaked.)

Calling std::make_unique was a way to constrain the call order, thus making things safe:

f(std::make_unique<MyClass>(param), g());             // Syntax B

Since then, C++17 has clarified the evaluation order, making Syntax A safe too, so here's my question: is there still a reason to use std::make_unique over std::unique_ptr's constructor in C++17? Can you give some examples?

As of now, the only reason I can imagine is that it allows to type MyClass only once (assuming you don't need to rely on polymorphism with std::unique_ptr<Base>(new Derived(param))). However, that seems like a pretty weak reason, especially when std::make_unique doesn't allow to specify a deleter while std::unique_ptr's constructor does.

And just to be clear, I'm not advocating in favor of removing std::make_unique from the Standard Library (keeping it makes sense at least for backward compatibility), but rather wondering if there are still situations in which it is strongly preferred to std::unique_ptr

Improve this question
11
  • 4
    However, that seems like a pretty weak reason --> Why it's a weak reason? It effectively reduces code duplication of type. As for the deleter, how often you are using a custom deleter when you use std::unique_ptr? It's not a argument to against make_unique Commented Dec 20, 2018 at 14:34
  • 4
    I say it's a weak reason because if there was no std::make_unique in the first place, I don't think that would be reason enough to add it to the STL, especially when it's a syntax which is less expressive than using the constructor, not more Commented Dec 20, 2018 at 15:26
  • 1
    If you have a program, created in c++14, using make_unique, you do not want the function to get removed from stl. Or if you want it to be backwards compatible. Commented Dec 20, 2018 at 15:31
  • 2
    @Serge That's a good point, but it's a bit besides the object of my question. I'll make an edit to make it clearer Commented Dec 20, 2018 at 15:44
  • 3
    @Eternal please stop refering to C++ Standard Library as STL as it is incorrect and creates confusion. See stackoverflow.com/questions/5205491/… Commented Dec 21, 2018 at 10:37

6 Answers 6

Reset to default
107

You're right that the main reason was removed. There are still the don't use new guidelines and that it is less typing reasons (don't have to repeat the type or use the word new). Admittedly those aren't strong arguments but I really like not seeing new in my code.

Also don't forget about consistency. You absolutely should be using make_shared so using make_unique is natural and fits the pattern. It's then trivial to change std::make_unique<MyClass>(param) to std::make_shared<MyClass>(param) (or the reverse) where the syntax A requires much more of a rewrite.

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

@reggaeguitar If I see a new I need to stop and think: how long is this pointer going to live? Did I handle it correctly? If there is an exception, is everything cleaned up correctly? I'd like to not ask myself those questions and waste my time on it and if I don't use new, I don't have to ask those questions.
Imagine you do a grep over all the source files of your project and don't find a single new. Wouldn't this be wonderful?
The main advantage of the "don't use new" guideline it that it's simple, so it's an easy guideline to give to the less experienced developers you may be working with. I hadn't realized at first, but that has value in and of itself
@NathanOliver You actually don't absolutely have to be using std::make_shared - imagine a case where the allocated object is big and there are a lot of std::weak_ptr-s pointing to it: it would be better to let the object be deleted as soon as the last shared pointer is destroyed and live with just a small shared area.
@NathanOliver you wouldn't. What I'm talking about is the disadvantage of std::make_shared stackoverflow.com/a/20895705/8414561 where the memory that was used to store the object can't be freed until the last std::weak_ptr is gone (even if all std::shared_ptr-s pointing to it (and consequently the object itself) have been already destroyed).
|
71

make_unique distinguishes T from T[] and T[N], unique_ptr(new ...) does not.

You can easily get undefined behaviour by passing a pointer that was new[]ed to a unique_ptr<T>, or by passing a pointer that was newed to a unique_ptr<T[]>.

Improve this answer

1 Comment

It's worse: It not only does not, it's flat-out unable to.
27

The reason is to have shorter code without duplicates. Compare

f(std::unique_ptr<MyClass>(new MyClass(param)), g());
f(std::make_unique<MyClass>(param), g());

You save MyClass, new and braces. It costs only one character more in make in comparison with ptr.

Improve this answer

3 Comments

Well, as I said in the question, I can see it's less typing with only one mention of MyClass, but I was wondering if there was a stronger reason to use it
In many cases deduction guide would help to eliminate the <MyClass> part in the first variant.
It's already been said in the comments for other answers, but while c++17 introduced template type deduction for constructors, in the case of std::unique_ptr it's disallowed. It has to do with distinguishing std::unique_ptr<T> and std::unique_ptr<T[]>
22

Every use of new has to be extra carefully audited for lifetime correctness; does it get deleted? Only once?

Every use of make_unique doesn't for those extra characteristics; so long as the owning object has "correct" lifetime, it recursively makes the unique pointer have "correct".

Now, it is true that unique_ptr<Foo>(new Foo()) is identical in all ways1 to make_unique<Foo>(); it just requires a simpler "grep your source code for all uses of new to audit them".

1 actually a lie in the general case. Perfect forwarding isn't perfect, {}, default init, arrays are all exceptions.

Improve this answer

6 Comments

Technically unique_ptr<Foo>(new Foo) isn't quite identical to make_unique<Foo>()... the latter does new Foo() But otherwise, yes.
@barry true, overloaded operator new is possible.
@dedup what foul C++17 witchcraft is that?
@Deduplicator while c++17 introduced template type deduction for constructors, in the case of std::unique_ptr it's disallowed. If has to do with distinguishing std::unique_ptr<T> and std::unique_ptr<T[]>
@Yakk-AdamNevraumont I didn't mean overloading new, I just meant default-init vs value-init.
|
2

Since then, C++17 has clarified the evaluation order, making Syntax A safe too

That's really not good enough. Relying on a recently-introduced technical clause as the guarantee of safety is not a very robust practice:

  • Someone might compile this code in C++14.
  • You would be encouraging the use of raw new's elsewhere, e.g. by copy-pasting your example.
  • As S.M. suggests, since there's code duplication, one type might get changed without the other one being changed.
  • Some kind of automatic IDE refactoring might move that new elsewhere (ok, granted, not much chance of that).

Generally, it's a good idea for your code to be appropriate/robust/clearly valid without resorting to language-laywering, looking up minor or obscure technical clauses in the standard.

(this is essentially the same argument I made here about the order of tuple destruction.)

Improve this answer

Comments

-2

Consider void function(std::unique_ptr(new A()), std::unique_ptr(new B())) { ... }

Suppose that new A() succeeds, but new B() throws an exception: you catch it to resume the normal execution of your program. Unfortunately, the C++ standard does not require that object A gets destroyed and its memory deallocated: memory silently leaks and there's no way to clean it up. By wrapping A and B into std::make_uniques you are sure the leak will not occur:

void function(std::make_unique(), std::make_unique()) { ... } The point here is that std::make_unique and std::make_unique are now temporary objects, and cleanup of temporary objects is correctly specified in the C++ standard: their destructors will be triggered and the memory freed. So if you can, always prefer to allocate objects using std::make_unique and std::make_shared.

Improve this answer

1 Comment

The author explicitly specified in question that in C++17 leaks shall not occur anymore. "Since then, C++17 has clarified the evaluation order, making Syntax A safe too, so here's my question: (...)". You did not answer his question.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.