智能指针是存储动态分配对象指针的类，用于生命周期的控制。当指针离开其作用域时，自动销毁动态分配的空间，防止内存泄漏。
使用智能指针需要包含头文件#include<memory>

shared_ptr

std::shared_ptr采用引用计数，每一个shared_ptr的拷贝都指向相同的内容，当最后一个shared_ptr析构的时候，内存被释放

初始化shared_ptr对象

#include<iostream>
#include<memory>
 
int main(){
    std::shared_ptr<int> p1(new int(1)); //方式1
    std::shared_ptr<int> p2 = p1; //方式2
    std::shared_ptr<int> p3; 
//方式3 reset，如果原有的shared_ptr不为空，会使原对象的引用计数减1
    p3.reset(new int(1));
       //方式4
    std::shared_ptr<int> p4 = std::make_shared<int>(2);

//使用方法例子：可以当作一个指针使用
    std::cout << *p4 << std::endl;
    //std::shared_ptr<int> p4 = new int(1);
    if(p1) { //重载了bool操作符
        std::cout << "p is not null" << std::endl;
    }
    int* p = p1.get();//获取原始指针 
    std::cout << *p << std::endl; 
}

指定删除器

当使用shared_ptr删除数组时，需要指定删除器
常用的写法有以下几种

#include<iostream>
#include<memory>
template<typename T>
std::shared_ptr<T> make_shared_array(size_t size) {
    return std::shared_ptr<T>(new T[size], std::default_delete<T[]>());
} 
int main(){
     //lambda
    std::shared_ptr<int> p(new int[10], [](int* p){delete [] p;});
       //指定默认删除器
    std::shared_ptr<int> p1(new int[10], std::default_delete<int[]>());
    //自定义泛型方法 
    std::shared_ptr<char> p2 = make_shared_array<char>(10);
}

使用的注意事项

不要用一个原始指针初始化多个shared_ptr

不要在函数实参中创建shared_ptr。
如下面中的例子。

//不同编译器执行结果可能不同
//如果以new int -> 调用g() -> 创建shared_ptr的顺序
//那么假如g()方法失败，直接导致内存泄漏 
void f(shared_ptr<int>(new int), g())

通过shared_from_this()返回this指针时，不要作为shared_ptr返回，因为this是一个裸指针，可能会导致重复析构。如下面例子中，sp1和sp2重复析构A对象，导致错误。如果需要返回this指针，可以通过继承enable_shared_from_this类，调用方法shared_from_this实现。如下面中注释掉的写法。
如果

#include<iostream>
#include<memory>
class A {
    public:
        std::shared_ptr<A> GetSelf() {
            return std::shared_ptr<A>(this);
        }
};
/*
class A :public std::enable_shared_from_this<A>{
    public:
        std::shared_ptr<A> GetSelf() {
            return shared_from_this();
        }
};
*/
int main(){
    std::shared_ptr<A> sp1(new A);
    std::shared_ptr<A> sp2 = sp1 -> GetSelf();
    
}

要注意循环引用带来的内存泄漏问题。如下面A与B循环引用，导致内存泄漏

#include<iostream>
#include<memory>
struct A;
struct B;
struct A {
    std::shared_ptr<B> bptr;
    ~A() {
        std::cout << "A is delete" << std::endl;
    }
};
struct B {
    std::shared_ptr<A> aptr;
    ~B() {
        std::cout << "B is delete " << std::endl;
    }
};
int main(){
    std::shared_ptr<A> ap(new A);
    std::shared_ptr<B> bp(new B);
    ap->bptr = bp;
    bp->aptr = ap;
}