求索阁

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