?一 unique_ptr概述

?? ?独占式的概念（专属所有权）：同一个时刻，只能有一个unique_ptr指针指向这个对象（这块内存）；
? ? 当这个unique_ptr被销毁的时候，它所指向的对象也被销毁；
?? ?格式；
?? ?unique_ptr<指向的对象类型> 智能指针变量名。

二功能测试代码

#include <stdio.h>
#include <memory>
#include <iostream>
#include <functional> 
class A{
public:
    A(int a):ma(a)
    {
        std::cout << "demoA 构造  "<<"ma:"<<ma<< std::endl;
    }
    A()
    {
        ma=100;
        std::cout << "demoA 构造 "<<"ma:"<<ma<< std::endl;
    }

   void getA(){
        std::cout << "测试a: " << ma<<std::endl;
    }
   ~A()
   {
      std::cout<<"demoA 析构"<< "ma:"<<ma<<std::endl;
   }
  public:
    int ma;
};
void deleter(A * x)
{
    std::cout << "Custom Deleter\n";
    delete[] x;
}

unique_ptr<A> backTest()
{
    unique_ptr<A> A_ptr(new A(9));
    return A_ptr;
}

int main(int argc, char *argv[])
{
    unique_ptr<A> A_ptr(new A(0));
    A_ptr->getA();

    //move左值转右值
    unique_ptr<A> A_ptr1 = std::move(A_ptr);
    A_ptr1->getA(); 


    //get使用
    A * A_ptr3 = A_ptr1.get(); //p指向的对象，获取裸指针
    A_ptr3->getA();


    //release使用放弃对指针的控制权（切断了智能指针和其所指向的对象之间的联系）。
	//返回裸指针，将该智能指针置空。返回的这个裸指针我们可以手工delete来释放，也可以用来初始化另外一个智能指针，或者给另外一个智能指针赋值。
   //A_ptr1.release(); 会导致内存泄漏。
    A * A_ptr4  = A_ptr1.release();  
    delete A_ptr4;      //
    A_ptr4 = nullptr;


    //reset 使用
    std::cout<<"-----------"<<endl;
    unique_ptr<A> A_ptr5;  // empty
    A_ptr5.reset (new A(5));       // reset()带参数的情况：释放智能指针所指向的对象，并让该智能指针指向新对象
    A_ptr5->ma=5;
    A_ptr5->getA();
    A_ptr5.reset();               // 释放A_ptr5

    A_ptr5.reset (new A(6));       
    A_ptr5->ma=7;
    A_ptr5->getA();
    A_ptr5.reset();
    std::cout<<"-----------"<<endl;


    //=使用
    unique_ptr<A> A_ptr6;
    unique_ptr<A> A_ptr61(new A(8));
    A_ptr6=unique_ptr<A>(new A(8));    //合法
    A_ptr6=A_ptr61              //报错不能直接=
    //返回值
    A_ptr6=backTest();         //返回值为临时对象可以相等
    A_ptr6.reset();
    std::cout<<"-----------"<<endl;

    //删除器
    typedef void(*fp)(A *);//typedef定义函数指针
    unique_ptr<A,fp> A_ptr7(new A[5],deleter);
    A_ptr7.reset();
    std::cout<<"-----------"<<endl;
    using fp2=void(*)(A *);//using定义函数指针
    unique_ptr<A,fp2> A_ptr8(new A[5],deleter);
    A_ptr8.reset();
    std::cout<<"-----------"<<endl;
    typedef decltype(deleter)* fd3; //decltype返回数据类型为void(A*),所以定义函数指针需要加*
    unique_ptr<A,fd3> A_ptr9(new A[5],deleter);
    A_ptr9.reset();
    //lambad表达式
    std::cout<<"-----------"<<endl;
    auto Fdele=[](A* x){ std::cout << "Custom Deleter\n";delete[] x;};//lambad表达式，可以理解为一个带operate()的类对象
    unique_ptr<A,decltype(Fdele)> A_ptr10(new A[5],Fdele); //所以可以理解decltype(deleter)=class{...}
    A_ptr10.reset();
    std::cout<<"-----------"<<endl;
    unique_ptr<A,function<void(A*)>> A_ptr11(new A[5],[](A* x){ std::cout << "Custom Deleter\n";delete[] x;});//function 定义函数指针
    A_ptr11.reset();
}