智能指针之共享指针

智能指针是存储指向动态分配对象指针的类。三种智能指针： std::shared_ptr/ std::unique_ptr/ std::weak_ptr.

使用时需要加上头文件 #include<memory>
1.共享智能指针--shared_ptr

　 初始化

    shared_ptr初始化可以通过reset方法初始化shared_ptr。

std::shared_ptr<int> p(new int(1));
std::shared_ptr<int> p2 = p;    //p和p2共享同一段内存
std::shared_ptr<int> ptr;
ptr.reset(new int(1));
int *p1 = new int[2];
std::shared_ptr<int> p3(p1);
if(ptr)
{
   cout << "ptr is not null";
}

另外还可以通过std::make_shared<T>辅助函数初始化，尽量使用std::make_shared<T>初始化共享指针，

auto p1 = std::make_shared<int>(10);
auto p2 = std::make_shared<string>(10,"s");

  可以通过重载的bool类型操作符判断智能指针是否为空，即是否未初始化。

if(bool(ptr))
    cout << "the ptr is nullptr"<<endl;
else
    cout << "the ptr is not nullptr"<<endl;

 

　 --获取原始指针
    　　用get()方法获取原始指针，如：

std::shared_ptr<int> ptr(new int(1));
int *p = ptr.get();

--指定删除器

    void deleteIntPtr(int* p)
    {
        delete p;
    }
    std::shared_ptr<int> p5(new int,deleteIntPtr);

   或者使用lambda表达式

std::shared_ptr<int> p6(new int,[](int* p){delete p;});

 //管理动态数组时，需要指定删除器,shared_ptr默认的删除器不支持数组对象

std::shared_ptr<int> p6(new int[10],[](int* p){delete[] p;});

  //或者使用std::default_delete作为删除器 

 std::shared_ptr<int> p7(new int[10],std::default_delete<int[]>);

 //此外还可以通过封装方法让shared_ptr支持数组    

    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[]>());
    }
    std::shared_ptr<int> p8 = make_shared_array<int>(10);
    std::shared_ptr<char> p9 = make_shared_array<char>(10);

 使用shared_ptr注意事项

    1.不能使用原始指针初始化多个shared_ptr
   

 int* p11 = new int;
    std::shared_ptr<int> p12(p11);
    std::shared_ptr<int> p13(p11);

 2.不要在实参中创建shared_ptr,应该先创建一个智能指针，再使用

    deleteIntPtr(std::shared_ptr<int>(new int));//错误的
    std::shared_ptr<int> p14(new int());
    deleteIntPtr(p14);//OK

3.要通过shared_from_this()返回this指针

struct A
{
    std::shared_ptr<A> getSelf()
    {
        return std::shared_ptr<A>(this);//错误，
    }
};
int main()
{
    std::shared_ptr<A> sp1(new A);
    std::shared_ptr<A> sp2 = sp1->getSelf();//会导致重复析构
　　 return 0;
}

　　采用如下方式，使用enable_shared_from_this类的shared_from_this()方法返回this指针：

class A:public std::enable_shared_from_this
{
public:
    std::shared_ptr<A> getSelf()
    {
        return shared_from_this();
    }
};

4.避免循环使用,如下A/B两个指针都不会被删除会有内存泄漏

 

struct A;
struct B;
struct A
{
    std::shared_ptr<B> bptr;
    ~A(){cout << "A is deleted!"<<endl;}
};
struct B
{
    std::shared_ptr<A> aptr;
    ~B() {cout << "B is deleted!"<<endl;}
};
int main()
{
    {
        std::shared_ptr<A> ap(new A);
        std::shared_ptr<B> bp(new B);
        ap->bptr = bp;
        bp->aptr = ap;
    
     }
}

 

　　

 

可以将A或B的任何一个shared_ptr成员改为weak_ptr。

 

 

参考：《深入应用C++1:代码优化与工程级应用》