unique

unique_ptr basic 1-1: create unique_ptr from new. make_unique is better than inside new, inside new is better than outside new.

string * cp = new string("hello␣world");

unique_ptr<string> ps = cp; // NOT allow

//ok, but not good style(outside new)
unique_ptr<string> ps (cp);

//good style(inside new)
unique_ptr<string> ps (new string("hello␣world"));

//best style make_unique
unique_ptr<string> ps( std::make_unique<int>(1) );

unique_ptr basic 1-2: When pass value into a function, 1) for exit unique_ptr, use move to transfer ownership, 2) for new unique_ptr, use make_unique to assure exception safe.

void sink( unique_ptr<widget> arg1, unique_ptr<gadget> arg2);

//1) use move
sink( std::move(exist_uptr_wi), std::move(exist_uptr_ga))

//2) use make function to assure exception safety.
sink( make_unique<widget>(new ...),
make_unique<gadget>(new ...) ); // exception-safe

unique_ptr basic 2-1: Create unique_ptr from another unique_ptr, you have to use move.

unique_ptr<string> ps1 (new string("hello␣world"));

unique_ptr<string> ps2 ( ps1 ); //compile error, not allow.
unique_ptr<string> ps2 ( move(ps1) ); //ok
//ownship transfer from ps1 to ps2, nothing delete.

unique_ptr basic 3: unique_ptr assignment

unique_ptr<string> ps1 (new string("ps1"));
unique_ptr<string> ps2 (new string("ps2"));

ps1= ps2; //compile error, not allow

//method1: use move
ps1 = std::move(ps2);
//pointer inside previous ps1 will be deleted.
// pointer inside ps1 point to "ps2" string now.
//pointer inside ps2 will set to null

//method2: reset
ps1.reset(cp); //ok
//pointer inside previous ps1 will be deleted.

unique_ptr basic 4-1: If a program attempts to assign one unique_ptr to another. The compiler allows it if the source object is a temporary rvalue (It will call move ctor or assignment of unique_ptr inside.) and disallows it if the source object has some duration. It is a move-only type.

unique_ptr<string> ps2 = _________________________________________________________uqique_ptr<string>(new string("yo") ); //OK

uqique_ptr<string> fun(){
return unique_ptr<string> temp(new string("yan");
}
pu2 = fun(); //OK

unique_ptr basic 4-2: unique_ptr support source and sink idiom.

unique_ptr fun() //support source

fun(unique_ptr up); //use move to support sink
fun(move(other_up));

unique_ptr basic 5: Just observer, not transfer ownership , you can get pointer, or use unique_ptr reference.

unique_ptr<string> ps1 (new string("ps1"));

fun(string* pstr);
fun(unique_ptr<string> & ref_ptr);

by default, std::unique_ptrs are the same size as raw pointers, so efficiency of it is just like raw pointer.

If your vector should hold std::unique_ptr<Fruit> instead of raw pointers (to prevent memory leaks). vector need copy in and copy out. but unique_ptr don’t support copy. So 1) you can use emplace_back with new pointer, but it will lead memory leak if extending vector size fail. 2) use unname unique_ptr, 3) use make_unique .

class Fruit { ... };
class Pear : Fruit { ... };
class Tomato : Fruit { ... };

std::vector<std::unique_ptr<Fruit> > m_fruits;
//method 1, bad
m_fruits.emplace_back(new Pear);

//method 2, good
m_fruits.push_back(std::unique_ptr<Fruit>(new Pear));
m_fruits.push_back(std::unique_ptr<Fruit>(new Tomato));

//method 3, best using std::make_unique:
m_fruits.push_back(std::make_unique<Pear>());
m_fruits.push_back(std::make_unique<Tomato>());

When in doubt, prefer unique_ptr by default, and you can always later move-convert to shared_ptr if you need it. If you do know from the start you need shared ownership, however, go directly to shared_ptr via make_shared. If you compiler report error about unique_ptr, then you should consider to use shared_ptr

Unique_ptr has new [] version. The existence of std::unique_ptr for arrays should be of only intellectual interest to you, because std::array, std::vector, and std::string are virtually always better data structure choices than raw arrays. About the only situation I can conceive of when a std::unique_ptr<T[]> would make sense would be when you’re using a C-like API that returns a raw pointer to a heap array that you assume ownership of it.

unique_ptr<double []> pda(new double[5] );
// it will call delete [] inside.

A common use for std::unique_ptr is as a factory function return type for objects in a hierarchy. detail can be seen "effective modern c++ item 18"

During construction, std::unique_ptr objects can be configured to use custom deleters: arbitrary functions (or function objects, including those arising from lambda expressions) to be invoked when it’s time for their resources to be destroyed. when a custom deleter can be implemented as either a function or a captureless lambda expression, the lambda is preferable.
When a custom deleter is to be used, its type must be specified as the second type argument to std::unique_ptr.

//only c++ 14 support return type deduction
template<typename... Ts>
____________auto makeInvestment(Ts&&... params) {
auto delInvmt = [](Investment* pInvestment) {
makeLogEntry(pInvestment); // makedelete
pInvestment; // Investment
};

std::unique_ptr<Investment, decltype(delInvmt)>
pInv(nullptr, delInvmt);

if (...){
pInv.reset(new Stock(________________________________________________std::forward<Ts>(params)...));
}
else if (... ) {
pInv.reset(new Bond(std::forward<Ts>(params)...));
}
return pInv; // as before
}

std::unique_ptr is the C++11 way to express exclusive ownership, but one of its most attractive features is that it easily and efficiently converts to a std::shared_ptr: This is a key part of why std::unique_ptr is so well suited as a factory function return type. Factory functions can’t know whether callers will want to use exclusive ownership semantics for the object they return or whether shared ownership

std::shared_ptr<Investment> sp = // converts std::unique_ptr
makeInvestment( arguments ); // to std::shared_ptr

unique_ptr can be used inside of class. Below class B disable value-copying (or to define a suitable copy-constructor and operator= to handle it safely).

class B {  // this class cann’t be
public:
   unique_ptr<int> i;
   B():i(new int(0)) { }
};

You can store unique_ptr objects in an STL container providing you don’t invoke methods or algorithm, such as copy(), that copy or assign one unique_ptr to another. see effective stl item 8.

bool compare_by_uniqptr(
               const unique_ptr<SomeLargeData>& a,
               const unique_ptr<SomeLargeData>& b) {
    return a->id < b->id;
}

sort(vec_byuniqptr.begin(), vec_byuniqptr.end(),
compare_by_uniqptr);

typedef std::unique_ptr<int> unique_t;
typedef std::vector< unique_t > vector_t;

vector_t vec2(5, unique_t(new Foo));     // Error (Copy)
vector_t vec3(vec1.begin(), vec1.end()); // Error (Copy)
std::copy(vec1.begin(), vec1.end(),
          std::back_inserter(vec2)); // Error (copy)

vector_t vec3(make_move_iterator(vec1.begin()),
                 make_move_iterator(vec1.end())); //Ok

std::sort(vec1.begin(), vec1.end());
// OK, because using Move Assignment Operator

1.1.10.4 unique_ptr