# Effective Modern C++:unique_ptr

You should include when using smart pointers

### unique_ptr

Just as its name means, unique_ptr guarantees that there is only one pointer point to a specific memory block. So it cannot be copied by only moved.

Init a unique_ptr

unique_ptr<int> p{ new int };
unique_ptr<int> p{ new int{4} };


As you can see, smart pointers are wraps of normal pointers, we call them “raw” pointers.

move a unique_ptr

unique_ptr<int> q = p; //wrong, copy is not allowed
unique_ptr<int> q = move(p);//move p to q
if (p == nullptr)
cout << "p is null now\n";


unique_ptr can only be moved, when the original unique_ptr is moved to another one, the original unique_ptr will be equal to nullptr.

delete a unique_ptr

p.release();


delete is not supported, you should use its “release” method.

use unique_ptr for factory pattern

unique_ptr<int> createnew(){
return unique_ptr<int>{new int{4}};
}//produce a unique_ptr


when you return a unique_ptr in a function, it is actually use its move method implicitly. So the unique_ptr is cleanly produced that you get the original, unique pointer.

What’s more, an unique_ptr can be moved to a shared_ptr!

	unique_ptr<int> q{ new int{4} };
shared_ptr<int> s = move(q);


That means you can do the following:

shared_ptr<int> createnewShared(){
return unique_ptr<int>{new int{ 4 }};
}//produce a shared_ptr


if you want to produce a shared_ptr, the original version as an unique_ptr is moved, which means the newly produced shared_ptr will be the only existed copy of the original version, this is very clean.

If you want to use unique_ptr for array, you should declare it as:

	int n = 5;
unique_ptr<int[]> intArray{ new int[n] };
for (int i = 0; i < n; i++)
intArray[i] = i;

-->

### Wangxin

I am algorithm engineer focused in computer vision, I know it will be more elegant to shut up and show my code, but I simply can't stop myself learning and explaining new things ...