一、shared_ptr
shared_ptr，使用引用计数实现对同一块内存可以有多个引用，在最后一个引用被释放时，指向的内存才释放，这也是和unique_ptr最大的区别。基本用法：
shared_ptr<int>sp1(new int(10));
cout << "sp1: " << sp1.use_count() << '\n';
cout << "sp1 = " << sp1 << " *sp1 = " << *sp1 << endl;
shared_ptr<int>sp2 = make_shared<int>(10);
cout << "sp2: " << sp2.use_count() << '\n';
cout << "sp2 = " << sp2 << " *sp2 = " << *sp2 << endl;输出：
?这个智能指针的特性“在最后一个引用被释放时，指向的内存才释放”。怎么理解这一点呢？使用自定义数据类型来看看：
class A {
public:
~A() {
cout << "dealloc A" << endl;
}
};
A* a = new A();
delete a; //调用~A
shared_ptr<A>spa = make_shared<A>(); //使用shared_ptr
cout << "spa: " << spa.use_count() << '\n';//可以看到引用计数为1
spa = nullptr;//将智能指针赋值为空指针后，先前指向内存的引用计数为0，内存被析构，调用~A
cout << "spa: " << spa.use_count() << '\n';//引用计数为0输出：
?最后看看不同方法使用智能指针的引用计数：
shared_ptr<int> p1;//默认构造，没有获取任何指针的所有权
shared_ptr<int> p2(nullptr);//同p1
shared_ptr<int> p3(new int);//拥有指向int的指针所有权
cout << "p1: " << p1.use_count() << '\n';
cout << "p2: " << p2.use_count() << '\n';
cout << "p3: " << p3.use_count() << '\n';
shared_ptr<int> p4(p3);//如果p3引用计数为0，则引用计数加1，否则同样为0
cout << "p4: " << p4.use_count() << '\n';
shared_ptr<int> p5(std::move(p4));//获取p4的引用计数
cout << "p5: " << p5.use_count() << '\n';
return 0;输出：
二、enable_shared_from_this
std::enable_shared_from_this 是一个模板类，能让一个对象t（被 std::shared_ptr 对象 pt1 管理）生成另一个?std::shared_ptr 实例pt2?，与 pt1 共享对象 t 的所有权。
一个类 T 继承 std::enable_shared_from_this<T> ，则会为该类 T 提供成员函数：shared_from_this 。 当 T 类型对象 t 被一个为名为 pt 的 std::shared_ptr<T> 类对象管理时，调用 T::shared_from_this 成员函数，将会返回一个新的 std::shared_ptr<T> 对象，它与 pt 共享 t 的所有权。
当类A被share_ptr管理，且在类A的成员函数里需要把当前类对象作为参数传给其他函数时，就需要传递一个指向自身的share_ptr。
struct A : std::enable_shared_from_this<A>
{
public:
std::shared_ptr<A> getptr() {
return shared_from_this();//调用shared_from_this()，返回一个新的shared_ptr<T>对象
}
~A() { std::cout << "A destroy" << std::endl; }
};
std::shared_ptr<A> gp1(new A());
std::shared_ptr<A> gp2 = gp1->getptr();
// 打印gp1和gp2的引用计数
std::cout << "gp1.use_count() = " << gp1.use_count() << std::endl;
std::cout << "gp2.use_count() = " << gp2.use_count() << std::endl;
return 0;输出：
三、weak_ptr
该类型指针通常不单独使用（没有实际用处），只能和 shared_ptr 类型指针搭配使用。可以视为 shared_ptr 指针的一种辅助工具。借助 weak_ptr 类型指针可以获取 shared_ptr 指针的一些状态信息，比如有多少指向相同的 shared_ptr 指针、通过expired()判断shared_ptr 指针指向的堆内存是否已经被释放等等。
weak_ptr 类型指针并不会影响所指堆内存空间的引用计数。当 weak_ptr 指针的指向和某一 shared_ptr 指针相同时，weak_ptr 指针并不会使所指堆内存的引用计数加 1；同样，当 weak_ptr 指针被释放时，之前所指堆内存的引用计数也不会因此而减 1。weak_ptr<T> 模板类中没有重载 * 和 -> 运算符，这也就意味着，weak_ptr 类型指针只能访问所指的堆内存，而无法修改它。
std::shared_ptr<int> sp1(new int(10));
std::shared_ptr<int> sp2(sp1);
cout << "sp1 : "<<sp1.use_count() << endl;
cout << "sp2 : "<<sp2.use_count() << endl;
std::weak_ptr<int> wp(sp2);
cout << "wp : "<<wp.use_count() << endl;
sp2 = nullptr;
cout << "wp : " << wp.use_count() << endl;
return 0;输出：
weak_ptr的一个作用是解决share_ptr的循环引用问题。如下面代码所示，A中引用B，B中引用A，spa和spb的强引用计数永远大于等于1，所以直到程序退出前都不会被退出，这种情况有时候在正常的业务逻辑中是不可避免的，而解决循环引用的方法是改用weak_ptr
class A {
public:
shared_ptr<B> b;
};
class B {
public:
shared_ptr<A> a;
};
int main(int argc, const char * argv[]) {
shared_ptr<A> spa = make_shared<A>();
shared_ptr<B> spb = make_shared<B>();
spa->b = spb;
spb->a = spa;
return 0;
} 使用weak_ptr
class A {
public:
shared_ptr<B> b;
~A()
{
cout << "A destroy" << endl;
}
};
class B {
public:
weak_ptr<A> a;
~B()
{
cout << "B destroy" << endl;
}
};
int main(int argc, const char* argv[]) {
shared_ptr<A> spa = make_shared<A>();
shared_ptr<B> spb = make_shared<B>();
cout << "spa = " << spa.use_count() << endl;
cout << "spb = " << spb.use_count() << endl;
spa->b = spb; //spb强引用计数为2，弱引用计数为1
spb->a = spa;
//spb->a为weak_ptr类型，不会增加强引用计数，所以spa强引用计数为1，弱引用计数为2
cout << "spa = " << spa.use_count() << endl;
cout << "spb = " << spb.use_count() << endl;
return 0;
} //main函数退出后，spa先释放，spb再释放，循环解开了输出：
?更详细内容参考：智能指针（三）：weak_ptr浅析_AlbertS Home of Technology-CSDN博客_weakptr
四、unique_ptr
unique_ptr也是一种智能指针，不过它独占被管理的内存地址，如果有其它指针指向它管理的内存地址，则会引发错误。可以用move函数给其他unique_ptr赋值，调用move后，原unique_ptr就会失效，再用其访问裸指针也会发生错误。
unique_ptr<int> up(new int(5));
auto up2 = up; // 编译错误
auto up2 = move(up);
cout << *up << endl; //错误，up已经失效，无法访问其裸指针