“unique_ptr”是“独占式智能指针”

名字透露身份，“unique_ptr”是“独占式智能指针”。使用它管理前面的O类指针：

演示1：

例中 p 是一个智能指针。其中的“<O>”指明它所指向的数据类型是“O”。除了创建方法不太一样，以及不用手工释放之外，智能指针使用上和它所管理的裸指针基本一样。

如果健忘而负责任的程序员，忘了p是智能指针，写出“delete p”这样的代码，也不用怕，编译器会就出这个错误。

例中的裸指针同样没有名字，在调用智能指针对象的构造函数是，直接使用new生成。这是推荐的做法，这样做的好处是，防止有人故意捣乱。

构建“unique_ptr”对象是，只能采用“构造式初始化”，不允许采用“赋值式初始化”

如果手头上确实已经有了一个裸指针，临时需要交给智能指针来管理，也是支持的：

O* po = new O();
std::unique_ptr <O> p(po);

这里有个细节，即构建“unique_ptr”对象是，只能采用“构造式初始化”，不允许采用“赋值式初始化”的语法：

std::unique_ptr <O> p2 = new O();//编译出错
O* po = new O();
std::unique_ptr <O> p = po; //同样编译出错

不允许将裸指针直接赋值给智能指针

这是刻意的设计，不允许将一个裸指针使用“=”赋值给智能指针。良好的智能指针就是这样一个纠结的设计：既要让它用起来就像一个裸指针，又要在关键的地方提醒一下你，它不是一个真的指针。

智能指针也可以有“空指向”的状态，构建时不传入裸指针即可：

std::unique_ptr <O> p; //空指向的智能指针
if(p == nullptr) //成立
{
    cout << "p is a nullptr" << endl;
}
if(!p)//也成立
{
    cout << "not p" << endl;
}

演示unique_ptr初始还方式:

以上都是让智能指针尽量用起来像裸指针的设计。背后的实现手段还是“重载操作符”。

智能指针当然可以改变指向,

只是同样不能使用“=”将裸指针赋给智能指针，右值必须同样是智能指针：

std::unique_ptr <O> p; //空指向的智能指针
...
p = std::unique_ptr <O> (new O);//不能省略为“p = new O”

但是这样写显得很冗长，可以改用“unique_ptr”带参版“reset(...)”的方法，用于改变一个“unique_ptr”的指向：

O* src1 = new O;
O* src2 = new O;
std::unique_ptr <O> p(src1); //先管理src1
...
p.reset(src2); //改为管理src2,改之前，src1将被释放

演示智能指针改变指向：

改变一个“unique_ptr”的指向，如果该智能指针不是空指向，会先释放原来管理的裸指针，再接管新的裸指针。这中间隐藏了一个风险，即新指向和旧指向，必须确保不是同一个对象：

O* o = new O;
std::unique_ptr <O> p(o); //p管理着o
p = std::unique_ptr <O>(o); //p改变指向，但其实还是指向o。

003行执行过程是这样的：在改变指向之前，p要先干掉当前所管理的裸指针，也就是o。然后再管理新的裸指针，不幸的是，这个所谓的“新”的裸指，仍然是o，刚刚被干掉的o。编译器无法帮我们识别这样的问题。

“unique_ptr”的独占性：

一个裸指针不能由多个“std::unique_ptr”管理，但编译器挡不住程序员刻意将一个裸指针交给多个“unique_ptr”管理，编译器无法阻止你干出“一女多嫁”的事情：

O* o = new O; //一个裸指针
std::unique_ptr <O> p1(o); //交给p1管
std::unique_ptr <O> p2(o); //又交给p2管

错误将在运行时发生，本例中由于O结构没有任何成员数据，所以发生这个错误的程序可能不会挂掉，但错误确实发生了，能够从屏幕输出o被释放两次

演示“一女多嫁”：

能不能“改嫁”呢？

O* o = new O; //还是一个裸指针
std::unique_ptr <O> p1(o); //先交给p1
std::unique_ptr <O> p2 = p1; //然后由p1转交个p2?
//std::unique_ptr <O> p2(p1); //同上，但使用更正规构造式初始化

逻辑上是说的通的，具体做法可以是：p1让出o,让给p2; p1变成空指向，并且C++中已经被标为“废弃”，但暂时还可使用老版本的智能指针“std::auto_ptr”，就是这么设计的。但事实003行或004行，都将编译失败。

C++ 11认为，这样偷偷修改源对象的做法太隐晦了，程序员难以直观地通过阅读代码“想起”这过程中源对象（例中的p1）变成空指向了。

演示“改嫁”：

转移函数std::move()

如果确实需要转移管理全，有两种方法。一种是明确使用C++11提供的转移函数：

std::unique_ptr <O> p2 = std::move(p1); //OK
//也可以std::unique_ptr <O> p2(std::move(p1)); //OK

包装一层“std::move”的调用，已明提示阅读者，p1的内容被“转移（move）”了，这就是“std::unique_ptr”作为“独占式”智能指针的最经典表现，即：不能将独占式智能指针A，赋值给独占式智能指针B，只能做转移。源方失去对裸指针的管理权，目标方获得。一失一得，裸指针的管理权仍然只属一方。

演示std::move()：

可以看到，裸指针只被释放了一次

release()方法：

实现转移管理权的另一种做法，是通过“std::unique_ptr”提供的“release()”方法。该方法可让一个智能指针“放手”它所“爱过”的裸指针：

std::unique_ptr <O> p(new O());
O* o = p.release(); //“吐出”所管理的裸指针

p吐出管理对象之后，自然变成空指向，而程序员手上拿着一个裸指针，又得考虑何时delete这个o对象。或者，干脆把它交给另一个智能指针管理吧，这是一个“迂回”的转移过程。

演示release()：

get()方法：

如果临时需要得到裸指针，但又不希望智能指针撒手不管，可以使用“std::unique_ptr”的“get()”方法：

std::unique_ptr <O> p(new O());
O* o = p.get();

演示get()方法：

、

unique_ptr变成空指向：unique_ptr被赋值裸指针的一个特例

赋裸指针：

如果想让一个“unique_ptr”变成空指向，倒是可以直接为它赋值nullptr,尽管前面我们刚说过不允许为“unique_ptr”赋值裸指针（而理论上nullptr是裸指针），这算是一个特例。

std::unique_ptr <O> p(new O());
...
p = nullptr;

演示赋裸指针：

reset()方法：

或者也可以使用“std::unique_ptr”的无入参版本的"reset()"方法：

p.reset();//让p变成空指向

演示reset方法: