Any use for dynamically allocating std::unique_ptr?

Question

Does it ever make sense to create a std::unique_ptr using new? In the snippet below as I suspected the SimpleClass object being managed by the std::unique_ptr won't be destroyed unless I delete the std::unique_ptr myself. I couldn't think of a situation where this is useful so I was wondering if there are situations where this is actually used.

  std::unique_ptr<vector_test::SimpleClass>* ptr_to_unique_ptr = new std::unique_ptr<vector_test::SimpleClass>();
  ptr_to_unique_ptr->reset(new vector_test::SimpleClass(555));
  delete ptr_to_unique_ptr;

I cannot think of a good use case for a raw pointer to a unique pointer to an object. If I were to find such a use case, I think I would try to use a unique pointer to the unique pointer to the object. — Eljay, Feb 16 '19 at 17:58
I can only think if you need shared ownership of the unique pointer... https://stackoverflow.com/questions/50831775/making-shared-ptr-lose-ownership-of-memory — Galik, Feb 16 '19 at 18:10
@Galik: And https://stackoverflow.com/a/28955443/103167 and https://stackoverflow.com/a/45510414/103167 — Ben Voigt, Feb 16 '19 at 18:22
I think this could just be named misuse. Every pros given by RAII would be neutralized. — fiorentinoing, Feb 16 '19 at 20:22

πάντα ῥεῖ · Accepted Answer · 2019-02-16T20:19:40.760

2

Does it ever make sense to create a std::unique_ptr using new?

Most probably not.

There's no concise reason why you would/should fall back to manual memory management while already using the standard dynamic memory allocation techniques.

I couldn't think of a situation where this is useful so I was wondering if there are situations where this is actually used.

I can't timagine either about such situation.

edited Feb 16 '19 at 20:19

answered Feb 16 '19 at 18:06

πάντα ῥεῖ

1
13
116
190

Your link is missing a character at the end in the URL but good answer. – Mike Sweeney Feb 16 '19 at 20:17
Thanks for notifying, fixed. – πάντα ῥεῖ Feb 16 '19 at 20:20

eerorika · Answer 2 · 2019-02-16T18:13:43.643

1

There is rarely a use for dynamically allocating a singular pointer. Closest real word use case is a singly linked list, where we dynamically allocate a class instance that contains a pointer, and some data associated with the node. Although, need to implement a linked list is rare because it is rarely the optimal choice of data structure, and because the standard library already provides decent designs of linked list.

Note that if we were to dynamically allocate a (smart) pointer, there is no good reason to not use a smart pointer to manage that allocation.

edited Feb 16 '19 at 18:13

answered Feb 16 '19 at 18:09

eerorika

232,697
12
197
326

Such situation can be boiled down using a `std::weak_ptr`, no? – πάντα ῥεῖ Feb 16 '19 at 18:13
@πάνταῥεῖ I'm not sure what situation you're suggesting. I haven't encountered good uses for weak pointers (although I don't doubt they exist). – eerorika Feb 16 '19 at 18:17

zett42 · Answer 3 · 2019-02-16T23:34:17.937

Does it ever make sense to create a std::unique_ptr using new?

I can't think of. There are situations where you want to prevent an object managed through a unique_ptr from deletion, when the scope that contains the unique_ptr ends. There are several ways to do this, without having to new the unique_ptr itself.

Some examples:

Move the object to another unique_ptr in a different scope.

std::unique_ptr<int> p1;
{
    std::unique_ptr<int> p2 = std::make_unique<int>( 42 );
    p1 = std::move( p2 );
    // Destructor of p2 won't delete object, because ownership was transferred.
}
// Scope of p2 has ended, but object is still managed by p1.
std::cout << *p1;

Return an object managed through a unique_ptr from a function.

std::unique_ptr<int> MyFun() {
    std::unique_ptr<int> p = std::make_unique<int>( 42 );
    return p;  // No explicit move required, because of RVO
}

Release ownership and get the raw pointer back.

std::unique_ptr<int> p = std::make_unique<int>( 42 );
some_C_API_that_takes_ownership( p.release() );
// Destructor of p won't delete object, because ownership was given up.

Any use for dynamically allocating std::unique_ptr?

3 Answers3