C++11智能指针（六）：unique_ptr介绍与例子

本节介绍下c++11提供的智能指针实现: std::unique_ptr<>

什么是std::unique_ptr

unique_ptr <>是c ++ 11提供的智能指针实现之一，用于防止内存泄漏。unique_ptr对象包含一个原始指针，并负责其生命周期。当这个对象被销毁的时候，它的析构函数会删除关联的原始指针。
unique_ptr有重载的- >和*运算符，所以它可以被用于类似于普通的指针。

示例：

#include <iostream>
#include <memory>

struct Task {
  int mId;
  Task(int id) : mId(id) {
    std::cout << "Task::Constructor" << std::endl;
  }
  ~Task() {
    std::cout << "Task::Destructor" << std::endl;
  }
};

int main() {
  //通过原始指针创建unique_ptr对象
  std::unique_ptr<Task> taskPtr(new Task(23));

  int id = taskPtr->mId;

  //通过unique_ptr访问元素
  std::cout << id << std::endl;

  return 0;
}

输出：

Task::Constructor
23
Task::Destructor

unique_ptr <Task>对象 taskPtr接受一个原始指针作为参数。当函数退出时，这个对象将超出范围，并且析构函数将被调用。在其析构函数中，unique_ptr对象taskPtr删除关联的原始指针。
所以，即使函数正常或异常退出（由于某些异常），taskPtr的析构函数将始终被调用。这样，原始指针总是会被删除，并防止内存泄漏。

唯一指针的唯一所有权

unique_ptr对象始终是关联的原始指针的唯一所有者。 我们不能复制一个unique_ptr对象，它只能移动。
由于每个unique_ptr对象是原始指针的唯一拥有者，因此在其析构函数中直接删除关联的指针。不需要任何参考计数，因此它非常轻量。

创建空的unique_ptr对象

//空unique_ptr对象
std::unique_ptr<int> ptr1;

ptr1没有与之关联的原始指针。 因此它是空的。

检查unique_ptr对象是否为空

有两种方法检查unique_ptr <>对象是否为空，或者是否有与之相关的原始指针：
方法1：

//检查unique_ptr对象是否为空
if(!ptr1)
	std::cout<<"ptr1 is empty"<<std::endl;

方法2：

//检查unique_ptr对象是否为空
if(ptr1 == nullptr)
	std::cout<<"ptr1 is empty"<<std::endl;

使用原始指针创建unique_ptr

要创建一个非空的unique_ptr <>对象，我们需要在构造函数中传递原始指针，同时创建对象。

//使用原始指针创建unique_ptr对象
std::unique_ptr<Task> taskPtr(new Task(23));

不能通过赋值创建unique_ptr<>对象，否则会导致编译错误

//std::unique_ptr<Task> taskPtr2 = new Task();   //编译错误

重置unique_ptr

调用unique_ptr<>对象上的reset()函数将重置该对象，即它将删除关联的原始指针并使unique_ptr<>对象为空：

//重置unique_ptr会删除关联的原始指针并使unique_ptr对象为空
taskPtr.reset();

unique_ptr对象不可复制

由于unique_ptr <>不可复制，只能移动。 因此，我们不能通过复制构造函数或赋值运算符来创建unique_ptr对象的副本。

//通过原始指针创建unique_ptr对象
std::unique_ptr<Task> taskPtr2(new Task(55));

//编译错误，unique_ptr对象不可复制
std::unique_ptr<Task> taskPtr3 = taskPtr2;

//编译错误，unique_ptr对象不可复制
taskPtr = taskPtr2;

复制构造函数和赋值运算符都在unique_ptr <>类中被删除。

转移unique_ptr对象的所有权

我们不能复制一个unique_ptr对象，但我们可以移动它们。这意味着一个unique_ptr对象可以将相关的原始指针的所有者转移到另一个unique_ptr对象。 让我们通过一个例子来理解：

创建一个unique_ptr对象

//通过原始指针创建unique_ptr对象
std::unique_ptr<Task> taskPtr2(new Task(55));

taskPtr2非空
现在将任务的关联指针的所有权转移给一个新的unique_ptr对象，即：

{
  //传递所有权
  std::unique_ptr<Task> taskPtr4 = std::move(taskPtr2);

  if(taskPtr2 == nullptr)
  std::cout<<"taskPtr2 is empty"<<std::endl;

  //所有权从taskPtr2传递给了taskPtr4
  if(taskPtr4 != nullptr)
  std::cout<<"taskPtr4 is not empty"<<std::endl;

  std::cout<<taskPtr4->mId<<std::endl;

  //taskPtr4超出了作用范围，删除相关原始指针
}

std :: move()把taskPtr2转换成一个RValue引用。所以unique_ptr的移动构造函数被调用，并且关联的原始指针可以被传送到taskPtr4。
将原始指针的所有权转移给taskPtr4后，taskPtr2将为空。

释放关联的原始指针

调用unique_ptr对象上的release()将释放对象的关联原始指针的所有权。

//通过原始指针创建unique_ptr对象
std::unique_ptr<Task> taskPtr5(new Task(55));

if(taskPtr5 != nullptr)
	std::cout<<"taskPtr5 is not empty"<<std::endl;
	
//释放来自原始指针的对象的所有权
Task * ptr = taskPtr5.release();

if(taskPtr5 == nullptr)
	std::cout<<"taskPtr5 is empty"<<std::endl;

完整的例子：

#include <iostream>
#include <memory>

struct Task {
  int mId;
  Task(int id) : mId(id) {
    std::cout << "Task::Constructor" << std::endl;
  }
  ~Task() {
    std::cout << "Task::Destructor" << std::endl;
  }
};

int main() {
  //空unique_ptr对象
  std::unique_ptr<int> ptr1;

  //检查unique_ptr对象是否为空
  if (!ptr1) {
    std::cout << "ptr1 is empty" << std::endl;
  }

  //检查unique_ptr对象是否为空
  if (ptr1 == nullptr) {
    std::cout << "ptr1 is empty" << std::endl;
  }

  //不能通过赋值初始化创建unique_ptr对象
  //std::unique_ptr<Task> taskPtr2 = new Task(); //编译错误

  //通过原始指针创建unique_ptr对象
  std::unique_ptr<Task> taskPtr(new Task(23));

  //检查taskPtr是否为空，或者是否有关联的原始指针
  if (taskPtr != nullptr) {
    std::cout << "taskPtr is  not empty" << std::endl;
  }

  //通过unique_ptr访问内部元素
  std::cout << taskPtr->mId << std::endl;

  std::cout << "Reset the taskPtr" << std::endl;
  //重置unique_ptr将删除关联的原始指针，并使unique_ptr对象为空
  taskPtr.reset();

  //检查taskPtr是否为空，或者是否有关联的原始指针
  if (taskPtr == nullptr) {
    std::cout << "taskPtr is  empty" << std::endl;
  }

  //通过原始指针创建unique_ptr对象
  std::unique_ptr<Task> taskPtr2(new Task(55));

  if (taskPtr2 != nullptr) {
    std::cout << "taskPtr2 is  not empty" << std::endl;
  }

  //unique_ptr 对象不可复制
  //taskPtr = taskPtr2；  //编译错误

  //unique_ptr 对象不可复制
  //std::unique_ptr<Task> taskPtr3 = taskPtr2; //编译错误

  {
    //转移所有权
    std::unique_ptr<Task> taskPtr4 = std::move(taskPtr2);

    if (taskPtr2 == nullptr) {
      std::cout << "taskPtr2 is  empty" << std::endl;
    }

    //taskPtr2的所有权转移给了task4
    if (taskPtr4 != nullptr) {
      std::cout << "taskPtr4 is not empty" << std::endl;
    }

    std::cout << taskPtr4->mId << std::endl;
    //taskPtr4超出范围并删除关联的原始指针
  }

  //通过原始指针创建unique_ptr对象
  std::unique_ptr<Task>taskPtr5(new Task(55));

  if (taskPtr5 != nullptr) {
    std::cout << "taskPtr5 is not empty" << std::endl;
  }

  //从原始指针释放对象的所有权
  Task* ptr = taskPtr5.release();

  if (taskPtr5 == nullptr) {
    std::cout << "taskPtr5 is empty" << std::endl;
  }

  std::cout << ptr->mId << std::endl;

  delete ptr;

  return 0;
}

输出：

ptr1 is empty
ptr1 is empty
Task::Constructor
taskPtr is  not empty
23
Reset the taskPtr
Task::Destructor
taskPtr is  empty
Task::Constructor
taskPtr2 is  not empty
taskPtr2 is  empty
taskPtr4 is not empty
55
Task::Destructor
Task::Constructor
taskPtr5 is not empty
taskPtr5 is empty
55
Task::Destructor