C++11 shared_ptr共享智能指针

小鱼儿 2022-06-13 11:46 147阅读 0赞

## 前言 ##

std::shared\_ptr使用引用计数，每一个shared\_ptr的拷贝都指向相同的内存。在最后一个shared\_ptr析构的时候，内存才会释放。

## 1. shared\_ptr基本使用方法 ##

### 1.1 初始化 ###

#include <memory>
    
    //智能指针初始化
    std::shared_ptr<int> p(new int(20));
    cout << *p << endl;
    
    std::shared_ptr<int> p2 = p;
    cout << *p2 << endl;
    
    std::shared_ptr<int> p3 = std::make_shared<int>();
    *p3 = 1024;
    cout << *p3 << endl;
    
    p3.reset(new int(-1));
    cout << *p3 << endl;
    
    std::shared_ptr<int> p4;
    if(p4)
    {
         cout << "ptr is null" << endl;
    }

**应当优先使用make\_shared来构造只能指针，因为它更加高效。**但是不能讲一个原始指针直接赋值给一个智能指针，例如，下面的这种情况就是错误的

std::shared_ptr<int> p = new int(20);

上面的代码会在编译的时候报错，不允许直接赋值。从上面的例子中可以看到智能指针的用法和普通指针的用法类似，只不过不需要自己管理分配的内存。shared\_ptr不能通过直接将原始指针赋值来初始化，需要通过构造函数或是辅助方法来初始化。对于一个未初始化的智能指针，可以通过reset方法来初始化，当智能指针中有值的时候，调用reset会使引用计数减1。另外之智能指针可以通过重载bool类型操作符来判断智能指针是否为空（未被初始化）。

### 1.2 获取原始指针 ###

使用get方法来返回原始指针

std::shared_ptr<int> p(new int(20));
    int *pp = p.get();

### 1.3 指定删除器 ###

智能指针的删除支持自定义删除函数，用法如下：

//自定义的删除智能指针函数
    void MyDeleteIntPtr(int *p)
    {
        cout << __FUNCTION__ << "delte ptr" << endl;
        delete p;
        p = nullptr;
    }
    
    //创建智能指针
    void MyMakeIntPtr()
    {
        cout << __FUNCTION__ << "make ptr" << endl;
        std::shared_ptr<int> P(new int(1034), MyDeleteIntPtr);  //指定删除的函数
        cout << "value:" << *P << endl;
    }
    
    MyMakeIntPtr();	//调用

但是这样的方式未免太过于麻烦了，那么可以写成这样的（使用lambda表达式）

void MyMakeIntPtr()
    {
        cout << __FUNCTION__ << "make ptr" << endl;
        std::shared_ptr<int> P(new int(1034), [](int *p){
                               cout << __FUNCTION__ << "delte ptr" << endl;
                               delete p;
                               p = nullptr;});  //指定删除的lambda表达式
        cout << "value:" << *P << endl;
    }

这里调用的函数也就是仿函数了。当使用shared\_ptr管理动态数组时，需要制定删除器，因为std::shared\_ptr的默认删除器不支持数组对象。使用的代码如下：

std::shared_ptr<int> P(new int[1034], [](int *p){
                          cout << __FUNCTION__ << "delte ptr" << endl;
                          delete[] p;
                          p = nullptr;});  //指定删除的lambda表达式

也可以使用自带的std::default\_delete作为删除器。default-delete的内部是通过调用delete来实现功能的，代码如下：

std::shared_ptr<int> P(new int[1034], std::defualt_delete<int[]>);

## 2. shared\_ptr注意事项 ##

只能只恨虽然能够自动管理内存，但它还是有不少缺陷，在使用时需要注意一下几点

### 2.1 不要使用一个原始指针去初始化多个shared\_ptr ###

int * ptr = new int(1024);
    std::shared_ptr<int> P(ptr);
    std::shared_ptr<int> P1(ptr);	//错误

### 2.2 不要再函数参数实参中创建shared\_ptr ###

function(shared_ptr<int>(new int), g());

上面的函数中写法是**有缺陷的**。这是因为C++的参数计算顺序在不同的编译器不同的调用约定下可能是不一样的，一般是从右到左，但是也有可能是从左到右，所以，可能的过程是先new int，然后调用g()。但是如果恰好g()发生了异常，而shared\_ptr<int>还没有创建，则int内存就泄露了，正确的写法应该是这样的

shared_ptr<int> p(new int);
    function(p, g());

### 2.3 通过shared\_ptr返回this指针 ###

struct A
    {
        std::shared_ptr<A> GetSelf()
        {
            return std::shared_ptr<A>(this);    //错误
        }
    };
    
    shared_ptr<A> p1(new A());
    shared_ptr<A> p2 = p1->GetSelf();

不要讲this指针作为shared\_ptr返回出来，因为this指针本质上是一个裸指针，因此，这样可能会导致重复析构。在上面的代码中构造了两个智能指针，当离开作用域之后this指针就会被两个智能指针各自析构，导致重复析构的问题。正确的使用方式是

struct A: public std::enable_shared_from_this<A>
    {
        std::shared_ptr<A> GetSelf()
        {
            return shared_from_this();
        }
    };
    
    shared_ptr<A> p1(new A());
    shared_ptr<A> p2 = p1->GetSelf();       //正确

### 4. 避免循环引用 ###

struct A
    {
        std::shared_ptr<B> aptr;
        ~A()
        {}
    };
    
    struct B
    {
        std::shared_ptr<A> aptr;
        ~B()
        {}
    };
    
    shared_ptr<A> p1(new A());
    shared_ptr<B> p2(new B());
    p1->bptr = p2;
    p2->aptr = p1;

上面的两个智能指针在构造的时候引用计数为1，但是在循环引用之后就变为了2 。在离开作用域之后两个只能指针减1，但是并不会变为0，导致两个只能指针不会被析构，产生内存泄露。解决办法是把A和B任何一个成员变量改为weak\_ptr。