【C++11及其特性】智能指针——unique_ptr

大家好,这里是国中之林!
❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看←

一.排他所有权模式

运行结果:

auto_ptr和unique_ptr都是排他所有权模式,就是一块内存只能一个指针来管理.

所以这个过程是p1先释放,然后被p2赋值,p2就释放了.

二.auto_ptr的缺点

1.可以直接复制和拷贝构造

这里就是可以直接赋值,但是其真正的跟我们的赋值又存在着差异.
不符合习惯.赋值后p2是空的.

2.STL可以直接赋值

原理和刚刚的赋值其实是一样的

3.不支持动态内存分配数组

auto_ptr只支持单个的动态内存分配.

三.unique_ptr(C++11)

1.不支持直接赋值和构造

unique_ptr则不允许直接赋值和构造,因为排他性.
这样也符合我们的习惯.

如果硬要转的话,可以用move移动语义,将左值变为右值.

2.STL可以不可以直接赋值

3.支持动态内存分配数组

四.unique_ptr的用法

以下将会用Test类来测试.

1.构造函数

• 没有指向值的.
  
• 直接初始化的.
  
• 数组的.
  
• 带删除器的,就是生命周期结束的话,调用的自定义的,可能要在释放前做点什么.
  
  
  运行结果:
  

2.赋值操作

• 通过reset()赋值
  
• 通过move语义赋值
  

3.主动释放对象

不用等生命周期结束.

4.放弃对象控制权

不管理其释放了.

5.重置

重置指向的指针.

6.交换

交换指向的指针.

五.排他性智能指针的陷阱

排他所有权模式,虽然让我们无法两个指针指向同一块内存.
但是当使用reset时,可以使其两个指针指向同一块内存了.
如果一个生命周期结束,那么下一个生命周期结束的话又会进行释放,导致重复释放.

六.完整代码

#include <iostream>
#include <memory>
#include <vector>
using namespace std;

int main1()
{
	auto_ptr<string>p1(new string("我是p1"));
	auto_ptr<string>p2(new string("我是p2"));
	cout << *p1 << endl;
	cout << *p2 << endl;
	cout << p1.get() << endl;
	cout << p2.get() << endl;
	p1 = p2;//排他所有权模式
	cout << *p1 << endl;
	//cout << *p2 << endl;//为空,不能访问
	cout << p1.get() << endl;
	cout << p2.get() << endl;
	cout << endl;

	vector<auto_ptr<string>>va;
	auto_ptr<string>p3(new string("我是p3"));
	auto_ptr<string>p4(new string("我是p4"));
	va.push_back(move(p3));
	va.push_back(move(p4));
	cout << va[0].get() << endl;
	cout << va[1].get() << endl;
	va[0] = va[1];
	cout << va[0].get() << endl;
	cout << va[1].get() << endl;
	cout << *va[0] << endl;
	//cout << *va[1] << endl;//不能访问为空

	//auto_ptr<int []>ai(new int[5]);

	//陷阱
	auto_ptr<string>p5;
	auto_ptr<string>p6;
	string* str = new string("智能指针的内存管理陷阱");
	p5.reset(str);
	{
		p6.reset(str);
	}
	cout << p6.get() << endl;
	cout << p5.get() << endl;
	system("pause");

	return 0;
}


int main2()
{
	unique_ptr<string>p1(new string("我是p1"));
	unique_ptr<string>p2(new string("我是p2"));
	cout << *p1 << endl;
	cout << *p2 << endl;
	cout << p1.get() << endl;
	cout << p2.get() << endl;
	//p1 = p2;//直接报错不允许
	//unique_ptr<string>p7(p1);//拷贝构造也不可以

	unique_ptr<string>p7(move(p1));
	p1 = move(p2);//只有只有才可以赋值

	cout << *p1 << endl;
	//cout << *p2 << endl;
	cout << p1.get() << endl;
	cout << p2.get() << endl;
	cout << endl;

	vector<unique_ptr<string>>va;
	unique_ptr<string>p3(new string("我是p3"));
	unique_ptr<string>p4(new string("我是p4"));
	va.push_back(move(p3));
	va.push_back(move(p4));
	cout << va[0].get() << endl;
	cout << va[1].get() << endl;
	//va[0] = va[1];//不允许赋值
	cout << va[0].get() << endl;
	cout << va[1].get() << endl;
	cout << *va[0] << endl;
	//cout << *va[1] << endl;

	//auto_ptr<int []>ai(new int[5]);
	unique_ptr<int[]>ui(new int[5]);//支持

	//陷阱
	auto_ptr<string>p5;
	auto_ptr<string>p6;
	string* str = new string("智能指针的内存管理陷阱");
	p5.reset(str);
	{
		p6.reset(str);
	}
	cout << p6.get() << endl;
	cout << p5.get() << endl;
	system("pause");

	return 0;
}

class Test
{
public:
	Test()
	{
		cout << "调用构造函数" << endl;
	}
	~Test()
	{
		cout << "调用析构函数" << endl;
	}

	void doSomething()
	{
		cout << "do...." << endl;
	}
};

class DestrucTest
{
public:
	void operator()(Test* p)
	{
		p->doSomething();
		delete p;
	}
};

int main()
{
	//赋值
	unique_ptr<Test>up1;
	Test* t = new Test();
	up1.reset(t);
	unique_ptr<Test>up2(new Test());
	unique_ptr<Test>up3;
	up3 = move(up2);
	up3.release();

	unique_ptr<Test[]>up4(new Test[5]);
	up4 = NULL;//主动释放,up4.reset()也可以
	

	{
		unique_ptr<Test, DestrucTest>up5(new Test());
	}

	unique_ptr<Test>up6(new Test());
	unique_ptr<Test>up7(new Test());
	up6.swap(up7);


	system("pause");
	return 0;
}

七.总结

用排他性的智能指针时,就用独一无二的unique_ptr.
auto_ptr已经被淘汰了!