Gdddk

Why am I allowed to create multiple unique pointers from a single object?

#include <iostream>
#include <memory>

using namespace std; 

class Class

public:
 Class(int a): int_(a)std::cout << "constr" << std::endl;
 ~Class()std::cout << "destr" << std::endl;
 int int_;

;

int main()

 Class a(4);
 std::unique_ptr<Class> ptr = std::make_unique<Class>(a);
 std::unique_ptr<Class> ptr2 = std::make_unique<Class>(a);
 std::unique_ptr<Class> ptr3 = std::make_unique<Class>(a);
 std::cout << ptr->int_ << std::endl;
 std::cout << ptr2->int_ << std::endl;
 std::cout << ptr3->int_ << std::endl;

 return 0;

Why not?

You are not creating multiple unique_ptr instances pointing to the same Class instance, but you are instead allocating three new Class instances on the heap, copy-constructed from a. Every unique_ptr points to a different instance.

std::unique_ptr<Class> ptr = std::make_unique<Class>(a);

The above means: create a new instance of Class on the heap, copy-constructed from a, and give ownership of it to a new std::unique_ptr instance with name ptr.

Why am I allowed to create multiple unique pointers from a single object?

You're not allowed to do that*, so it's a good thing you're not doing that!

Don't forget, this:

std::unique_ptr<Class> ptr = std::make_unique<Class>(a);

is this**:

std::unique_ptr<Class> ptr(new Class(a));

not this:

std::unique_ptr<Class> ptr(&a);

std::make_unique creates a thing and gives you a unique_ptr to that thing. It does so by forwarding its arguments to the thing's constructor. Admittedly this can be confusing when you pass in the name of an existing object, leading to the copy constructor being used.

tl;dr: You're creating copies of a.

_{* Well, with a no-op deleter you could do it safely, but let's save that conversation for another day…
** More or less…}

Why am I allowed to create multiple unique pointers from a single object?

You're allowed to make multiple copies of the object, because the class is copyable.

"Unique" in unique_ptr doesn't mean that the pointed object is the unique instance of its class. It means that no other pointer should have ownership of the pointed object. In your example, each unique pointer points to a separate instance; each of the uniquely owned by the respective pointer.

You could^† violate the uniqueness like this:

std::unique_ptr<Class> ptr(&a);

^†Could: The program would be well-formed and compiler would be required to compile it. But the behaviour of the program would then be undefined, so you very much should not do that.