智能指针是一个类，用来存储指向动态分配对象的指针，负责自动释放动态分配的对象，防止内存泄漏。动态分配的资源交给一个类对象去管理，当类对象声明周期结束时，自动调用析构函数释放资源。
shared_ptr
采用引用计数器的方法，允许多个智能指针指向同一个对象，每当多一个指针指向该对象时，指向该对象的所有智能指针内部的引用计数加1，每当减少一个智能指针指向对象时，引用计数减1，当计数为0时自动释放动态分配的资源。
#include <memory>
#include <string>
#include <iostream>
using namespace std;
int main(int argc, char** argv)
{
string str = "hello world";
shared_ptr<string> p1(new string(str));
shared_ptr<string> p2(p1);
shared_ptr<string> p3 = p1; //允许多个指针指向同一个对象
cout << *p1 << endl;
cout << *p2 << endl;
cout << *p3 << endl;
shared_ptr<string> ps1;
//从普通指针构造智能指针
string* str1 = new string("xian");
//ps1 = str1; //隐式转换不可以
ps1 = shared_ptr<string>(str1); //显示转换可以
//shared_ptr<string> ps2 = str1; //隐式转换不可以
//shared_ptr<string> ps3(str1); //显式转换(出现程序崩溃，因为多个智能指针指向了同一块内存，会引起重复释放内存的问题),
shared_ptr<string> ps3(ps1); //多个智能指针指向同一块内存，但是使用智能指针是采用引用计数的原理，只有当引用计数为0时，才delete这块内存
cout << *ps1 << endl;
cout << *ps3 << endl;
return 0;
}
auto_ptr
主要是为了解决“有异常抛出时发生内存泄漏”的问题。因为发生异常而无法正常释放内存。auto_ptr有拷贝语义，拷贝后源对象变得无效，程序崩溃，而unique_ptr没有拷贝语义，提供了移动语义（使用std::move）进行转移。所以unique_ptr比auto_ptr更安全。
#include <iostream>
using namespace std;
int main(int argc, char** argv)
{
string* str1 = new string("hello ");
auto_ptr<string> p1(str1);
auto_ptr<string> p2(p1); //自动将p1的所有权剥夺，导致p1无法访问，不够安全，建议使用unique_ptr
//cout << *p1 << endl;
cout << *p2 << endl;
return 0;
}
unique_ptr
采用独享所有权定义，一个非空的unique_ptr总是拥有它所指向的资源，转移一个unique_ptr会把所有权全部从源指针转移给目标指针，源指针被置空；所以unique_ptr不支持普通的拷贝和赋值操作。
#include <iostream>
using namespace std;
int main(int argc, char** argv)
{
string* str1 = new string("hello ");
unique_ptr<string> p1(str1);
//unique_ptr<string> p2 = p1; //不允许这样做
unique_ptr<string> p2 = move(p1);
//cout << *p1 << endl; //p1已经丧失了所有权
cout << *p2 << endl;
return 0;
}
weak_ptr
弱引用。引用计数有一个问题就是互相引用形成环（环形引用），这样两个指针指向的内存都无法释放。需要使用weak_ptr打破环形应用，是为了配合shared_ptr而引入的一种智能指针，它指向一个由shared_ptr管理的对象而不影响所指对象的生命周期，也就是说它只引用，不计数。
#include <iostream>
using namespace std;
class A;
class B;
class A
{
public:
//shared_ptr<B> b_ptr;
weak_ptr<B> b_ptr; //修改为若应用即可解决循环引用的问题
};
class B
{
public:
//shared_ptr<A> a_ptr;
weak_ptr<A> a_ptr; //修改为若应用即可解决循环引用的问题
};
int main(int argc, char** argv)
{
string* str1 = new string("hell0");
shared_ptr<string> p(str1);
//weak_ptr<string> p1(str1); //出错
weak_ptr<string> p1(p); //可以指向已有的shared_ptr
//cout << *p1 << endl; //不支持*操作
cout << p1.use_count() << endl; //查看与自己指向同一个对象的shared_ptr的引用计数，但是自己只引用不会增加或减少计数
shared_ptr<string> p2 = p1.lock();
cout << *p2 << endl; //借助lock函数返回一个和p1指向同一个对象的shared_ptr类型指针，获取其存储的数据。
cout << p1.use_count() << endl;
//**************循环引用******************
shared_ptr<A> pa(new A);
shared_ptr<B> pb(new B);
pa->b_ptr = pb;
pb->a_ptr = pa;
//如果不是弱引用，两个的引用计数都为2，这个情况下最后的引用计数不为2，造成两个内存得不到释放，导致内存泄漏
cout << "pa.use_count=" << pa.use_count() << endl;
cout << "pb.use_count=" << pb.use_count() << endl;
return 0;
}
