c++中的四个智能指针：shared_ptr, unique_ptr, weak_ptr, auto_ptr

为什么使用智能指针？
智能指针的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束时忘记释放，造成内存泄漏。使用智能指针可以很大程度上避免这个问题，因为智能指针是一个类，当超出了这个类的作用范围时，类自动调用析构函数，析构函数会释放资源。所以智能指针的作用原理就是在函数自动结束时自动释放内存空间，不需要手动释放内存空间。

1. auto_ptr(c++98方案，c++11以丢弃)
   采用所有权模式。

	auto_ptr<string> p1(new string("hello world"));
	auto_ptr<string> p2;
	//当一个智能指针交出所有权时，自己是否会调用析构函数？
	p2 = p1;
	cout << *p2 << endl;

当p1将所有权交出时，编译器显示p1的值为empty（被销毁）,为空，这时再访问p1会在运行时产生错误。所以auto_ptr的缺点是存在潜在内存崩溃问题。

2. unique_ptr（替换auto_ptr）
   unique_ptr实现独占式拥有或严格拥有概念，保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄漏(例如“以new创建对象后因为发生异常而忘记调用delete”)特别有用。

	unique_ptr<string> p3(new string("see you!"));
	unique_ptr<string> p4;
	p4 = p3;//报错

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

	unique_ptr<string> p3(new string("see you!"));
	unique_ptr<string> p4;
	p4 = p3;//报错
	unique_ptr<string> pu3;
	pu3 = unique_ptr<string>(new string("you"));//允许

其中p4=p3后，会产生一个p3指针悬挂(dangling pointer)，这可能造成危害。然而，pu3 = unique_ptr<string>(new string("you"));不会产生悬挂的unique_ptr，因为它调用unique_ptr的构造函数，该构造函数创建的临时对象在其所有权交给pu3后就会被销毁。这种随情况而定的行为表明，Unique_ptr由于允许两种赋值的auto_ptr。
注，如果非要将p3赋给p4，想安全的重用指针，可使用c++标准库函数std::move()，可以让你将一个unique_ptr赋值给另一个。例如：

	unique_ptr<string> p3(new string("see you!"));
	unique_ptr<string> p4;
	p4 = std::move(p3);//允许，同时p3被销毁
	cout << *p4 <<  endl;

如果出现该语句cout<<*p3<<endl;编译器不会报错，但在运行时会出现错误，p3为null。

	unique_ptr<string> p3(new string("see you!"));
	unique_ptr<string> p4;
	p4 = std::move(p3);//允许，同时p3被销毁
	cout << *p4 <<  endl;
	p3 = new string("bi");//不允许
	p3 = unique_ptr<string>(new string("scn"));//允许
	cout << *p3 << endl;

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

   shared_ptr是为了解决auto_ptr在对象所有权上的局限性(auto_ptr是独占的)，在使用引用计数的机制上提供了可以共享所有权的智能指针。

   成员函数：
   use_count：返回引用计数的个数
   unique：返回是否独占所有权(use_count=1)
   swap：交换两个shared_ptr对象（即交换所拥有的对象）
   reset：放弃内部对象的所有权或拥有对象的变更，会引起原有对象的引用计数的减少。调用的引用计数置0.
   get：返回内部对象（指针），由于已经重载了()方法，因此和直接使用对象是一样的。如shared_ptr\<int> sp(new int(1));，sp与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。

#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;

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;
}

结果：

2
2

可以看到fun函数中的pa，pb之间相互引用，两个资源的引用计数为2，当要跳出函数时，智能指针pa，pb析构时两个资源引用计数会减1，但是两者的引用计数还是为1，导致跳出函数时资源没有被释放（A B析构函数没有被调用），如果把其中一个改为weak_ptr就可以了。把类A里面的shared_ptr改为weak_ptr，如下：

#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;

class B;
class A {
public:
	weak_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;
}

运行结果如下：

1
2
B delete
A delete

这样的话，资源B的引用计数开始就是1，当pb析构时，B的计数变为0，B得到释放，B得到释放的同时也会使A的计数减1，同时pa析构时使A计数减1，那么A的计数为0，A得到释放。

注意：我们不能通过weak_ptr直接访问对象的方法，比如B对象有一个方法sayhello()，不能这样访问pa->pb_->sayhello();pb_是一个weak_ptr，应该先把它转换为shared_ptr，如下：shared_ptr p = pa->pb_.lock();p->sayhello();
完整具体如下：

#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;

class B;
class A {
public:
	weak_ptr<B> pb_;
	~A() {
		cout << "A delete\n";
	}
};

class B
{
public:
	shared_ptr<A> pa_;
	~B() {
		cout << "B delete\n";
	}
	void sayhello() {
		cout << "B said hello!" << endl;
	}
};

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;


	shared_ptr<B> p = pa->pb_.lock();
	p->sayhello();
}
int main() {
	
	fun();
	return 0;
}

运行结果如下：

1
2
B said hello!
B delete
A delete