C++的四种智能指针

参考： C++如何正确使用智能指针？作者：是凡双吖

1.auto_ptr(C++11已弃用)

auto_ptr 是C++标准库提供的类模板，当auto_ptr对象生命周期结束时，auto_ptr类的析构函数会自动释放指针指向的内存。即使发生异常，通过异常的栈展开过程也能将动态内存释放。auto_ptr不支持new 数组。
构造智能指针：

auto_ptr<string>p1( new string("123") );//直接构造

int p2 = new int(56);
auto_ptr<int>p3(p2);//将已存在的指向动态内存的普通指针作为参数来构造

auto_ptr<string>p4( new string("123") );
auto_ptr<string>p5(p4);//利用已经存在的智能指针来构造新的智能指针，可能会造成两个指针指向同一内存

虽然auto_ptr可以智能析构指针，但也有一些缺陷，请看如下代码：

auto_ptr<string> p1(new string ("123”));
auto_ptr<string> p2;
p2 = p1; //auto_ptr不会报错.

虽然代码此时不会报错，但p2剥夺了p1的所有权，但是当程序运行时访问p1将会报错，因为p1此时已经不再拥有内存，编程了一个空指针。所以auto_ptr的缺点是：存在潜在的内存崩溃问题！

要避免这种问题，方法有多种：
1.定义赋值运算符，使之执行深拷贝。这样两个指针将指向不同的对象，其中一个对象是另一个对象的副本，缺点是浪费空间，所以智能指针都未采用此方案。
2.建立所有权概念。对于特定的对象，只能有一个指针可拥有，这样所拥有对象的智能指针的析构函数会删除该对象。然后让赋值操作转让所有权。这就是用于auto_ptr和unique_ptr的策略。
3.跟踪引用对象的智能指针数。这称为引用计数。例如：赋值时，计数加1，指针过期时，计数减1。当减为0时才调用delete。这就是sheared_ptr采用的策略。

2.unique_ptr（替换auto_ptr）

unique_ptr实现独占式拥有或严格拥有概念，保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露(例如“以new创建对象后因为发生异常而忘记调用delete”)特别有用。
unique_ptr的操作表（引用自C++ primer）：

构造unique_ptr指针：

unique_ptr<string>p1;//可以指向一个string类型的unique_ptr
unique_ptr<int>p2( new int(3) );//p2指向一个值为3的int

unique_ptr<int>p3(p2);//错误，unique_ptr对一个对象有完全“拥有”权，不支持拷贝
p3=p2;//错误，unique_ptr对一个对象有完全“拥有”权，不支持赋值

但我们可以通过其他方式，转移unique_ptr的所有权至另一个unique_ptr指针：

unique_ptr<int>p1( new int(3) );
unique_ptr<int>p2( p1.release() );//将指向值为3的所有权转移给p2，并释放p1原来指向的内存
p1.reset( p2.release() );//p2所有权转让给p1，并释放p2指向的内存

注意，我们不能单独的使用release()函数，如果我们不用另一个只能智能来存储release()返回的指针，那么我们会丢失此指针：

p1.release();//错误，返回的指针没有得到保存，我们将丢失此指针，p1的内存将无从释放

//正确做法
auto p2 = p1.release();
delete p2;

使用场景：
unique_ptr 在默认情况下和裸指针一样，内存上没有任何的额外消耗，性能是最优的。
1.仅在某个函数内临时创建一个指针对象处理某些事情，在函数结束后，对象随机销毁。但在处理过程中，可能会因为某种异常导致函数提前返回——此时，若使用原本的new指针，过多的异常就需要许多个对应的delete来释放内存，如下代码所示：

int test()
{
	int *pTest = new int();
	//do something
	...
	if(err1)
	{
		delete pTest;
		return errnum;
	}
	//do something
	...
	if(err2)
	{
		delete pTest;
		return errnum;
	}
	delete pTest;
	return succnum;
}

但如果我们用 unique_ptr，就不需要如此复杂。无论代码如何异常，在 unique_ptr 离开函数作用域的时候，内存就将会自动释放。

3.shared_ptr

shared_ptr实现共享式拥有概念。多个智能指针可以指向相同对象，该对象和其相关资源会在“最后一个引用被销毁”时候释放。从名字share就可以看出了资源可以被多个指针共享，它使用计数机制来表明资源被几个指针共享。可以通过成员函数use_count()来查看资源的所有者个数。除了可以通过new来构造，还可以通过传入auto_ptr, unique_ptr,weak_ptr来构造。当我们调用release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。
操作表（引用自C++ primer）：

构造指针：

shared_ptr<string> pb(new string("123"));
shared_ptr<int> p1 = make_shared<int>(42);//指向值为42的int,make_shared是安全的分配和使用动态内存的方法
shared_ptr<string> p2 = make_shared<string>(10，‘9’);//指向值为“9999999999”的string

shared_ptr<int> p3(p1);p3和p1指向相同的对象，此对象有两个引用者，此时引用计数为2

使用场景：
使用shared_ptr时，首先需要考虑是否真的需要使用shared_ptr而非unique_ptr。
1.多个对象共同管理一片内存
2.对象的延迟销毁。陈硕在《Linux 多线程服务器端编程》中提到，当一个对象的析构非常耗时，甚至影响到了关键线程的速度。可以使用shared_ptr将对象转移到另外一个线程中释放，从而解放关键线程。

4.weak_ptr

weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是那个强引用的 shared_ptr. weak_ptr只是提供了对管理对象的一个访问手段。weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。weak_ptr是用来解决shared_ptr相互引用时的死锁问题,如果说两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，它可以通过调用lock函数来获得shared_ptr。
操作表（引用自C++ primer）：

构造指针：

//weak_ptr的构造，必须由一个shared_ptr初始化
shared_ptr<int> p1 = make_shared<int>(42);
weak_ptr<int>p2(p1);//p2弱共享p1，shared_ptr的引用计数不会增加，并且p2的对象可能会被释放掉

因为weak_prt的对象可能被释放掉不存在，所有我们不能直接访问对象，而是调用lock()函数，此函数检查weak_ptr访问的对象是否还存在，若存在，返回一个shared_ptr对象：

if(shared_ptr<int> p3 = p2.lock())
{
	...
}

注意如下实例：

class B;
class A
{
public:
shared_ptr<B> pb_;
~A()
{
cout<<"A delete\n";
}
};
class B
{
public:
shared_ptr<A> pa_;
~B()
{
cout<<"B delete\n";
}
};
void fun()
{
shared_ptr<B> pb(new B());
shared_ptr<A> pa(new A());
pb->pa_ = pa;
pa->pb_ = pb;
cout<<pb.use_count()<<endl;
cout<<pa.use_count()<<endl;
}
int main()
{
fun();
return 0;
}

可以看到fun函数中pa ，pb之间互相引用，两个资源的引用计数为2，当要跳出函数时，智能指针pa，pb析构时两个资源引用计数会减一，但是两者引用计数还是为1，导致跳出函数时资源没有被释放（A B的析构函数没有被调用），如果把其中一个改为weak_ptr就可以了，我们把类A里面的shared_ptr pb_; 改为weak_ptr pb_; 运行结果如下，这样的话，资源B的引用开始就只有1，当pb析构时，B的计数变为0，B得到释放，B释放的同时也会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。