C++指针指针----unique_ptr

Mike

　　
　　文章目录

• 
  
  
  
  • 
    
    
    
    • unique_ptr
      
    • 
      
      
      
      • 基本使用
        
      • 创建空的unique_ptr对象
        
      • new一个unique_ptr对象
        
      • make_unique创建unique_ptr对象
        
      • 获取被管理对象的指针
        
      • 重置 unique_ptr 对象
        
      • 转移 unique_ptr 对象的所有权
        
      • 释放关联的原始指针
        
      • 总结
        
      • 完整代码
        
      
      
    
    
  
  

　　unique_ptr
　　unique_ptr 是 C++ 11 提供的用于防止内存泄漏的智能指针中的一种实现
基本使用

#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));
  //通过 unique_ptr 访问其成员
  int id = taskPtr->mId;
  std::cout << id << std::endl;
  return 0;
}

　　在return0之后自动调用析构函数释放内存

Task::Constructor
23
Task::Destructor

　　unique_ptr <Task> 对象 taskPtr 接受原始指针作为参数。现在当main函数退出时，该对象超出作用范围就会调用其析构函数，在unique_ptr对象taskPtr 的析构函数中，会删除关联的原始指针，这样就不用专门delete Task对象了
创建空的unique_ptr对象

std::unique_ptr<int> ptr1;

　　判断unique_ptr 对象是否为空或者是否有与之关联的原始指针

// 方法1
if(!ptr1)
std::cout<<"ptr1 is empty"<<std::endl;
// 方法2
if(ptr1 == nullptr)
std::cout<<"ptr1 is empty"<<std::endl;

new一个unique_ptr对象

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

make_unique创建unique_ptr对象
　　std::make_unique<>() 是C++ 14 引入的新函数

std::unique_ptr<Task> taskPtr = std::make_unique<Task>(34);

获取被管理对象的指针
　　sdt::unique_ptr::get();

std::unique_ptr<Task> taskPtr = std::make_unique<Task>(34);
  Task* p1 = taskPtr.get();
  std::cout << p1->mId << std::endl;

重置 unique_ptr 对象

taskPtr.reset();

转移 unique_ptr 对象的所有权

// 通过原始指针创建 taskPtr2
std::unique_ptr<Task> taskPtr2(new Task(55));
// 把taskPtr2中关联指针的所有权转移给taskPtr4
std::unique_ptr<Task> taskPtr4 = std::move(taskPtr2);
// 现在taskPtr2关联的指针为空
if(taskPtr2 == nullptr)
std::cout<<"taskPtr2 is  empty"<<std::endl;
// taskPtr2关联指针的所有权现在转移到了taskPtr4中
if(taskPtr4 != nullptr)
std::cout<<"taskPtr4 is not empty"<<std::endl;
// 会输出55
std::cout<< taskPtr4->mId << std::endl;

　　std::move() 将把 taskPtr2 转换为一个右值引用。因此，调用 unique_ptr 的移动构造函数，并将关联的原始指针传输到 taskPtr4。在转移完原始指针的所有权后， taskPtr2将变为空。
释放关联的原始指针
　　在 unique_ptr 对象上调用 release()将释放其关联的原始指针的所有权，并返回原始指针。这里是释放所有权，并没有delete原始指针，reset()会delete原始指针。

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;

总结
成员函数作用reset()重置unique_ptr为空，delete其关联的指针。release()不delete关联指针，并返回关联指针。释放关联指针的所有权，unique_ptr为空。get()仅仅返回关联指针use_count()获取引用计数std作用std::make_unique创建 unique_ptr 对象C++14std::move()对象转移

• 智能指针管理的是堆上面的指针，（栈上面的地址会造成两次调用析构）
  
• shared_ptr相当于一个指针，拷贝和赋值会是的引用加一
  

std::shared_ptr<Person> p1(new Person(1));// Person(1)的引用计数为1
std::shared_ptr<Person> p3 = p1;//现在p1和p3同时指向Person(1)，Person(3)的引用计数为2
std::cout<<p3.use_count()<<std::endl;//引用计数为2
std::cout<<p1.use_count()<<std::endl;//引用计数为2

• 只有当引用计数为0时，才会释放内存
  

/*接上面的代码*/
p1.reset();//Person(1)的引用计数为1
//p3.reset();//Person(1)的引用计数为0，析构Person(3)
//只重置p1，不重置p3，内存不会释放

完整代码

#include <iostream>
#include <memory>
using namespace std;
class Person
{
public:
  Person(int v) {
    value = v;
    std::cout << "Cons" <<value<< std::endl;
  }
  ~Person() {
    std::cout << "Des" <<value<< std::endl;
  }
  int value;
};
int main()
{
  std::shared_ptr<Person> p1(new Person(1));// Person(1)的引用计数为1
  std::shared_ptr<Person> p2 = std::make_shared<Person>(2);
  p1.reset(new Person(3));// 首先生成新对象，然后引用计数减1，引用计数为0，故析构Person(1)
  // 最后将新对象的指针交给智能指针
  std::shared_ptr<Person> p3 = p1;//现在p1和p3同时指向Person(3)，Person(3)的引用计数为2
std::cout<<p3.use_count()<<std::endl;
std::cout<<p1.use_count()<<std::endl;
  p1.reset();//Person(3)的引用计数为1
  //p3.reset();//Person(3)的引用计数为0，析构Person(3)
  std::cout<<"over"<<std::endl;
  return 0;
}

Cons1
Cons2
Cons3
Des1
2
2
over
Des3
Des2

　　关于子类继承父类，智能指针引用匿名函数lambda解决