现在的位置: 首页 > 自动控制 > 工业·编程 > 正文

C++11智能指针(六):unique_ptr介绍与例子

2019-04-24 22:27 工业·编程 ⁄ 共 4648字 ⁄ 字号 暂无评论

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

给我留言

留言无头像?