C++四种智能指针详解

四种智能指针：shared_ptr，unique_ptr，weak_ptr，auto_ptr

C++里面的四个智能指针：shared_ptr，unique_ptr，weak_ptr，auto_ptr其中前三个是c++11支持，并且最后一个已经被11弃用。

智能指针的使用

智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。C++11中最常用的智能指针类型为 shared_ptr它采用引用计数的方法，记录当前内存资源被多少个智能指针引用。该引用计数的内存在堆上分配。当新增一个时引用计数加1，当过期时引用计数有引用计数为0时，智能指针才会自动释放引用的内存资源。对 shared_ptr进行初始化时不能将—个普通指针直接赋值给智能指针，因为一个是指针，一个是类。可以通过 make_shared函数或者通过构造函数传入普通指针，并可以通过get函数获得普通指针。
1. auto_ptr（C++98方案，C++11已弃用）
采用所有权模式

auto_prt<string> p1(new string("Hello World"));
auto_ptr<string> p2;
p2 = p1; // auto_ptr不会报错

此时不会报错，p2剥夺了p1的所有权，但是当程序运行时访问p1将会报错。所以auto_pt的缺点是：存在潜在的内存崩溃问题！
2. unique_ptr（替换auto_ptr）
unique_ptr实现独占式拥有或严格拥有概念，保证同时间内只有一个智能指针可以指向该对象。它对于避免资源泄露（例如"以new创建对象后因为发生异常而忘记调用 delete"）特别有用采用。
采用所有权模式，还是上面那个例子

unique_prt<string> p3(new string("Hello World"));
unique_ptr<string> p4;
p4 = p3; // 此时程序会报错

编译器认为p4=p3非法，避免了p3不再指向有效数据的问题。因此unique_ptr比auto_ptr更安全。
另外 unique_pt还有更聪明的地方：当程序试图将—个 unique_prt赋值给另—个时，如果源unique_ptr是个临时右值，编译器允许这么做；如果源 unique_ptr将存在一段时间，编译器将禁止这么做，比如：

unique_prt<string> pt1(new string("Hello World"));
unique_ptr<string> pt2;
pt2 = pt1;                                             // #1 not allowed
unique_ptr<string> pt3;
pt3 = unique_ptr<string> (new string("Hello World"));  // #2 allowed;

其中#1留下悬挂的 unique_ptr（pt1，这可能导致危害。而#2不会留下悬挂的 unique_ptr，因为它调用 unique_ptr的构造函数，该构造函数创建的临时对象在其所有权让给pt3后就会被销毁。这种随情况而已的行为表明，unique_ptr优于允许两种赋值的 auto_ptr。
注：如果确实想执行类似与#1的操作，要安全的重用这种指针，可给它赋新值。C++有一个标准库函数std::move()，让你能够将一个unique_ptr赋给另一个。例如：

unique_ptr<string> ps1, ps2;
ps1 = demo("hello");
ps2 = move(ps1);
ps1 = demo("world");
cout << *ps2 << *ps1 <<endl;

3. share_ptr
shared_ptr实现共享式拥有概念。多个智能针可以指向相同对象，该对象和其相关资源会在“最后—个引用被销毁”时候释放。从名字 share就可以看出了资源可以被多个指针共享，它使用计数机制来表明资源被几个指针共享。可以通过成员函数 use_count()来查看资源的所有者个数。除了可以通过new来构造，还可以通过传入 auto_ptr, unique_ptr, weak_ptr来构造。当我们调用 release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。
shared_ptr是为了解决 auto_ ptr在对象所有权上的局限性（ auto_ ptr是独占的），在使用引用计数的机制上提供了可以共享所有权的智能指针。
成员函数：
use_count：返回引用计数的个数
unique：返回是否是独占所有权（ use_count为1）
swap：交换两个shared_ptr对象即交换所拥有的对象
reset：放弃内部对象的所有权或拥有对象的变更会引起原有对象的引用计数的减少
get：返回内部对象指针，由于已经重载了()方法因此和直接使用对象是一样的。如share_ptr sp(new int(1)); sp.get()是等价的
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。

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得到释放。

注意的是我们不能通过 weak_ptr直接访问对象的方法，比如B对象中有一个方法 print()我们不能这样访问，pa->pb-> print()；因为pb是个 weak_ptr，应该先把它转化为shared_ptr，如：shared_ptr p= pa->pb_.locke; p->print();