unique_ptr

unique_ptr是一种定义在<memory>中的智能指针(smart pointer)。它持有对对象的独有权——两个unique_ptr不能指向一个对象，不能进行复制操作只能进行移动操作。unique_ptr在超出作用域，即以下情况时它指向的对象会被摧毁：
    unique_ptr指向的对象被破坏
    对象通过operator=（）或reset（）被指定到另一个指针）
unique_ptr还可能没有对象，这种情况被称为empty。
例如：
std::unique_ptr<int>p1(newint(5));
std::unique_ptr<int>p2=p1;// 编译会出错
std::unique_ptr<int>p3=std::move(p1);// 转移所有权, 现在那块内存归p3所有, p1成为无效的针.
p3.reset();//释放内存.
p1.reset();//无效

 

unique_ptr是一个独享所有权的智能指针，它提供了一种严格语义上的所有权，包括：

    1、拥有它所指向的对象。

    2、无法进行复制构造，也无法进行复制赋值操作。也就是说，我们无法得到指向同一个对象的两个unique_ptr。但是可以进行移动构造和移动赋值操作。

    3、保存指向某个对象的指针，当它本身被删除释放的时候（比如，离开了某个作用域），会使用给定的删除器释放它指向的对象。

    使用unique_ptr，可以实现以下功能，包括：

    1、为动态申请的内存提供异常安全。

    2、将动态申请内存的所有权传递给某个函数。

    3、从某个函数返回动态申请内存的所有权。

    4、在容器中保存指针。

    5、所有auto_ptr应该具有的（但无法在C++ 03中实现的）功能。

    下面是一段传统的会产生不安全异常的代码：

1 X* f()
2 {
3     X* p = new X;
4     // 做一些事情，可能会抛出某个异常
5    return p;
6 }

    解决方法是，使用unique_ptr来管理这个对象的所有权，由其进行这个对象的释放工作。

1 X* f()
2 {
3      unique_ptr<X> p(new X);
4      // 做一些事情，可能会抛出异常
5     return p.release();
6 }

    如果程序执行过程中抛出了异常，unique_ptr就会释放它所指向的对象。但是，除非我们真的需要返回一个内建的指针，我们还可以返回一个unique_ptr。

1 unique_ptr<X> f()
2 {
3       unique_ptr<X> p(new X);
4       // 做一些事情，可能会抛出异常
5     return p;
6 }

    现在，我们可以这样使用函数f()：

1 void g()
2 {
3        unique_ptr<X> q = f();              // 使用移动构造函数（move constructor）
4      q->DoSomething();                   // 使用q
5        X x = *q;                                  // 复制指针q所指向的对象
6 }    // 在函数退出的时候，q以及它所指向的对象都被删除释放

    unique_ptr具有移动语义，所以我们可以使用函数f()返回的右值对q进行初始化，这样就简单地将所有权传递给了q。

 

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <sstream>
#include <memory>

using namespace std;

class A {
public:
  A() {};
  ~A() {
    cout << "Destructor" << endl;
  }

  void doSomething() {
    cout << "--------------------" << endl;
    std::ostringstream os;
    os << "ss" << "sx";
    os << "xx" << endl;
    cout << os.str();
    const std::string out = os.str();
    cout << "out:" << out.c_str();

    const std::string str = "6958abc123";
    if (str.find("abc") == string::npos) {
      printf("1111111\n");
    } else {
      printf("22222\n");
    }

    cout << "---------------------" << endl;
  }
};

unique_ptr<A> f()
{
  unique_ptr<A> a(new A);
  return a;
}


void test() {
  unique_ptr<A> a = f();  //超过a的作用域，则A对象自动被释放
  A *a1 = a.get();
  cout << "111" << endl;
  a1->doSomething();
  cout << "test() end" << endl;
}

int main() {
  test();
  cout << "to be continued !" << endl;
  exit(0);
}

mutian@mutian:~/soft/compile/now$ g++ -std=c++0x test.cpp
mutian@mutian:~/soft/compile/now$ ./a.out
111
--------------------
sssxxx
out:sssxxx
22222
---------------------
test() end
Destructor
to be continued !