CODEWITHSUNDEEP
c++c++11
Me myself and I
Me myself and I

Reputation: 4070

How is a unique_ptr unique?

I know unique_ptrs cannot be copied only moved and they have no reference counting. But we can have two smart pointers that share a resource:

Foo* f = new Foo;
auto p1 = std::unique_ptr<Foo>(f);
auto p2 = std::unique_ptr<Foo>(f);

Now both of these classes share a pointer to *f. Also, I know this will eventually cause UB because we will be doing double delete but still: What do we really mean by a unique_ptr being "unique" if this is possible?

Upvotes: 2

Views: 361

Answers (6)

shoulderstack
shoulderstack

Reputation: 57

Not wishing to put words in the OP's mouth, but I think the issue they may be raising might be to do with naming. Perhaps they are saying something like:

'Aaaaah! It makes no sense! The language is a work of lunacy! Lunacy, I tell you! Run! Run! Save yourselves!'.

If that's what the OP is hinting at then...

Rather than look for 'meaning' in C++ words and symbols, just try to remember their actual effects. eg 'unique' doesn't mean 'One only', even though it appears to mean exactly that, it merely has the effect of indicating that the ptr should be used in certain ways and not others. Similarly, 'Private' does not mean private, but has an effect on how something is shared. 'Static' things can move, and 'move' keeps things where they are to avoid copying them to a new location.

All you have to do is read the documentation forever, and accept the pain. See also 'Alice Through The Looking-Glass'.

Upvotes: 0

Theolodis
Theolodis

Reputation: 5092

Beside the fact that I do not believe that this is wanted or portable behaviour, I think that a unique_ptr is also a statement to other people working on the same project.

From the reference:

std::unique_ptr is a smart pointer that retains sole ownership of an object through a pointer and destroys that object when the unique_ptr goes out of scope. No two unique_ptr instances can manage the same object.

As I understand this, the behaviour of the sample you showed is actually not wanted and should not be used at all.

For people without knowledge of the subject (aka programming for dummies): What the OP does is like having two girlfriends, not knowing of each other. You're fine until they find out. When they do, and they definitely will, you'll probably wish you wouldn't have played with the fire.

Upvotes: 5

John Dibling
John Dibling

Reputation: 101506

Your question is akin to,

How is a crescent wrench a wrench when I can use it to drive nails in to the wall?

In other words, just because you can incorrectly use a tool to do something that shouldn't be done with it, doesn't mean it can't do what it was designed to do.

A unique_ptr is unique in the sense that you won't make copies of the pointer if you use it correctly. It ensures that there's only one controlling object, and that the controlled object is destroyed properly when the container is destroyed.

Upvotes: 3

Mike Seymour
Mike Seymour

Reputation: 254751

It's unique because, when used correctly, it represents a unique ownership model - only one pointer gives access to, and controls the lifetime of, an object. Compare this to shared_ptr, which represents a shared ownership model - more than one pointer can be used to access and manage the same object.

As you point out, you can break that model by messing around with dumb pointers (either keeping hold of the one used to initialise the smart pointer, or by using get() or similar to bypass the ownership model). As always, it's up to the programmer to be careful not to do the wrong thing with dumb pointers. There is nothing a smart pointer can do to control the use of dumb pointers.

Upvotes: 2

Matthieu M.
Matthieu M.

Reputation: 300399

To understand the terminology, you have to contrast unique_ptr and shared_ptr:

  • the former should be the sole responsible for managing the resource it points to
  • the latter should be sharing this responsibility with a set of peers

Often times, you will hear the term ownership to describe the responsibility of cleaning up.

Now, like many things in C++, you can attempt to subvert the system: only the intention is described, it's up to you to uphold your end of the bargain.

Upvotes: 3

Maxim Egorushkin
Maxim Egorushkin

Reputation: 136515

This is about ownership semantics:

  • Sole or unique ownership (e.g. std::unique_ptr and the old friend std::auto_ptr): only one pointer at a time owns an object.
  • Shared ownership (e.g. std::shared_ptr, boost::intrusive_ptr, linked_ptr): many pointers share the same object.

Upvotes: 2

Related Questions