c++智能指针---unique_ptr

介绍

• unique_ptr独享它指向的对象，也就是说，同时只有一个unique_ptr指向同一个对象，当这个unique_ptr被销毁时，指向的对象也随即被销毁。
• 实现代码（重要部分）
  • 第一个模板参数T：指针指向的数据类型。
  • 第二个模板参数D：指定删除器，缺省用delete释放资源。

#include <memory>
template <typename T, typename D = default_delete<T>>
class unique_ptr
{
public:
	explicit unique_ptr(pointer p) noexcept;				// 不能隐式转换
	~unique_ptr() noexcept;    
	T& operator*() const;            						// 重载*操作符
	T* operator->() const noexcept;  						// 重载->操作符
	unique_ptr(const unique_ptr &) = delete;   				// 禁用拷贝构造函数
	unique_ptr& operator=(const unique_ptr &) = delete;  	// 禁用赋值函数
	unique_ptr(unique_ptr &&) noexcept;	  					// 右值引用
	unique_ptr& operator=(unique_ptr &&) noexcept;  		// 右值引用
	// ...
private:
	pointer ptr;  // 内置的指针。
};

• 为了方便后面举例，先定义AA类

class AA
{
public:
    AA() { cout << "构造函数AA()" << endl; }
    AA(const string& name): m_name(name) { cout << "构造函数AA(" << name << ")" << endl; }
    ~AA() {cout << "析构函数~AA()" << endl; }
public:
    string m_name;
};

几种初始化的方式

// 第一种，不推荐
AA *pa = new AA();
unique_ptr<AA> pu = pa;

// 第二种
unique_ptr<AA> pu(new AA());

// 第三种，C++14标准。
unique_ptr<AA> pu = make_unique<AA>("亚瑟");

使用方法

• 智能指针重载了*和->操作符，可以像使用指针一样使用unique_ptr。

unique_ptr<AA> pu(new AA("亚瑟"));
cout << pu->m_name << endl;
cout << (*pu).m_name << endl;

• 通过get()获取管理的指针

unique_ptr<AA> pu(new AA("亚瑟"));
AA* pa = pu.get();

• 不支持普通的拷贝和赋值（源码里面禁用了）

//拷贝
unique_ptr<AA> pu_1(new AA("亚瑟"));
// unique_ptr<AA> pu_2 = pu_1; 错误，禁止拷贝

// unique_ptr<AA> pu_2;
// pu_2 = pu_1; 错误，禁止赋值

• 不要用同一个裸指针初始化多个unique_ptr对象

AA* pa = new AA("亚瑟");
unique_ptr<AA> pu_1(pa);
unique_ptr<AA> pu_2(pa);

• 用于函数的参数
  • 传引用（不能传值，因为unique_ptr没有拷贝构造函数）

  // 传引用
  void fun1(unique_ptr<AA>& pu) {
      cout << pu->m_name << endl;
  }
  unique_ptr<AA> pu_1(new AA("亚瑟"));
  fun1(pu_1);
  

一些需要注意的地方

1. 允许临时右值赋值给unique_ptr

unique_ptr<AA> fun2() {
    unique_ptr<AA> pu(new AA("亚瑟1"));
    return pu;
}

void test04()
{
    unique_ptr<AA> pu;
    pu = fun2(); 	// fun2返回临时值
    	
 	unique_ptr<AA> pu_2;
    pu_2 = unique_ptr<AA>(new AA("亚瑟2"));	// 临时值
}

通常来说，unique_ptr的拷贝和赋值函数都被禁用了，上面两种情况可行，是因为都是临时变量，如果unique_ptr存活了一段时间，就不行。

// pu是全局变量
unique_ptr<AA> pu(new AA("亚瑟1"));
unique_ptr<AA> fun2() {
   // return pu;	出错
}

2. 用nullptr给unique_ptr赋值将释放对象

unique_ptr<AA> pu(new AA("亚瑟1"));
cout << "赋值前" << endl;
pu = nullptr;
cout << "赋值后" << endl;

当给pu = nullptr调用析构函数

3. release()释放对原始指针的控制权，将unique_ptr置为空，返回管理的指针。（可用于把unique_ptr传递给子函数，子函数将负责释放对象）

void fun3(AA* p)
{
    cout << p->m_name << endl;
    delete p;
}


void test06()
{
    unique_ptr<AA> pu(new AA("亚瑟1"));
    fun3(pu.release());
}

这里fun3()里接管了指针，将它delete p，因此unique_ptr应该把管理权交出来。
还有一种使用如下所示：

unique_ptr<AA> pu_1(new AA("亚瑟1"));
unique_ptr<AA> pu_2(pu_1.release());	// 将pu_1管理指针转移给pu_2

4. std::move()可以转移对原始指针的控制权。（可用于把unique_ptr传递给子函数，子函数形参也是unique_ptr）

void fun4(unique_ptr<AA> pu)
{
    cout << pu->m_name << endl;
}


void test07()
{
    unique_ptr<AA> pu(new AA("亚瑟1"));
    cout << "开始调用" << endl;
    fun4(move(pu));
    cout << "结束调用" << endl;
}

结果可以看到，move将pu的指针控制权让出，并传给fun4的形参，由形参接管，析构是在fun4中完成的。

5. reset()释放对象

pp.reset();        			// 释放pp对象指向的资源对象。
pp.reset(nullptr);  		// 释放pp对象指向的资源对象
pp.reset(new AA("bbb"));  	// 释放pp指向的资源对象，同时指向新的对象

通过reset和release方法可以实现unique_ptr的转移

unique_ptr<AA> pu_1(new AA("亚瑟1"));
unique_ptr<AA> pu_2;
pu_2.reset((pu_1.release());	// 将pu_1管理指针转移给pu_2

6. swap()交换两个unique_ptr的控制权

unique_ptr<AA> pu_1(new AA("亚瑟1"));
unique_ptr<AA> pu_2(new AA("亚瑟2"));

cout << "swap前" << endl;
cout << "pu_1: " << pu_1->m_name << endl;
cout << "pu_2: " << pu_2->m_name << endl;

pu_1.swap(pu_2);

cout << "swap后" << endl;
cout << "pu_1: " << pu_1->m_name << endl;
cout << "pu_2: " << pu_2->m_name << endl;

7. unique_ptr同样可以使用多态
8. unique_ptr不是绝对安全，如果程序中调用exit()退出，全局的unique_ptr可以自动释放，但局部的unique_ptr无法释放。
9. unique_ptr提供了支持数组的具体化版本。

// unique_ptr<int[]> parr1(new int[3]);          // 不指定初始值。
unique_ptr<int[]> parr1(new int[3]{ 33,22,11 });  // 指定初始值。
cout << "parr1[0]=" << parr1[0] << endl;
cout << "parr1[1]=" << parr1[1] << endl;
cout << "parr1[2]=" << parr1[2] << endl;

unique_ptr<AA[]> parr2(new AA[3]{string("西施"), string("冰冰"), string("幂幂")});
cout << "parr2[0].m_name=" << parr2[0].m_name << endl;
cout << "parr2[1].m_name=" << parr2[1].m_name << endl;
cout << "parr2[2].m_name=" << parr2[2].m_name << endl;