C++智能指针

最新推荐文章于 2024-11-02 20:20:37 发布
最新推荐文章于 2024-11-02 20:20:37 发布
阅读量193 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 智能指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63601133/article/details/133898221
版权

智能指针的使用和原理

智能指针的使用

内存泄漏的问题

内存泄漏是指因为疏忽或错误，造成程序未能释放已经不再使用的内存的情况。

int div()
{
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}
void func()
{
    int* ptr = new int;
    //...
    cout << div() << endl;
    //...
    delete ptr;
}
int main()
{
    try
        {
            func();
        }
    catch (exception& e)
        {
            cout << e.what() << endl;
        }
    return 0;
}

执行上述代码时，如果用户输入的除数为0，那么div函数中就会抛出异常，这时程序的执行流会直接跳到主函数中的catch块中执行，最终导致func函数中申请的内存资源没有得到释放。

利用异常的重新捕获解决

对于这种情况，我们可以在func函数中先对div函数中抛出异常进行捕获，捕获后先将之前申请的内存资源释放，然后再将异常重新抛出

int div()
{
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}
void func()
{
    int* ptr = new int;
    try
    {
        cout << div() << endl;
    }
    catch (...)
    {
        delete ptr;
        throw;
    }
    delete ptr;
}
int main()
{
    try
    {
        func();
    }
    catch (exception& e)
    {
        cout << e.what() << endl;
    }
    return 0;
}

利用智能指针解决

我们使用智能指针试试

template<class T>
class SmartPtr
{
public:
    SmartPtr(T* ptr)
        :_ptr(ptr)
    {}
    ~SmartPtr()
    {
        cout << "delete: " << _ptr << endl;
        delete _ptr;
    }
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
private:
    T* _ptr;
};
int div()
{
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}
void func()
{
    SmartPtr<int> sp(new int);
    //...
    cout << div() << endl;
    //...
}
int main()
{
    try
    {
        func();
    }
    catch (exception& e)
    {
        cout << e.what() << endl;
    }
    return 0;
}

代码中将申请的内存空间交给了一个SmartPtr对象进行管理。

  • 在构造SmartPtr对象时，SmartPtr将传入的需要被管理的内存空间保存起来。
  • 在SmartPtr对象析构时，SmartPtr的析构函数中会自动将管理的内存空间进行释放。
  • 此外，为了让SmartPtr对象能够像原生指针一样使用，还需要对 * 和 -> 运算符进行重载。

这样一来，无论程序时正常执行完毕返回了，还是因为某些原因中途返回，或是因为抛异常返回了，只要SmartPtr对象的生命周期结束就会调用其对应的析构函数，进而完成内存资源的释放。

智能指针的原理

智能指针的原理

实现智能指针时需要考虑以下三个方面的问题：

  1. 在对象构造时获取资源，在对象析构的时候释放资源，利用对象的生命周期来控制程序资源，即RAII特性。
  2. 对*和->运算符进行重载，使得该对象具有像指针一样的行为。
  3. 智能指针对象的拷贝问题。

概念说明： RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、互斥量等等）的简单技术。

为什么要解决智能指针对象的拷贝问题

对于当前实现的SmartPtr类，如果用一个SmartPtr对象来拷贝构造另一个SmartPtr对象，或是将一个SmartPtr对象赋值给另一个SmartPtr对象，都会导致程序崩溃。比如：

int main()
{
    SmartPtr<int> sp1(new int);
    SmartPtr<int> sp2(sp1); //拷贝构造

    SmartPtr<int> sp3(new int);
    SmartPtr<int> sp4(new int);
    sp3 = sp4; //拷贝赋值

    return 0;
}

原因如下：

  • 编译器默认生成的拷贝构造函数对内置类型完成值拷贝（浅拷贝），因此用sp1拷贝构造sp2后，相当于这sp1和sp2管理了同一块内存空间，当sp1和sp2析构时就会导致这块空间被释放两次。
  • 编译器默认生成的拷贝赋值函数对内置类型也是完成值拷贝（浅拷贝），因此将sp4赋值给sp3后，相当于sp3和sp4管理的都是原来sp3管理的空间，当sp3和sp4析构时就会导致这块空间被释放两次，并且还会导致sp4原来管理的空间没有得到释放。

需要注意的是，智能指针就是要模拟原生指针的行为，当我们将一个指针赋值给另一个指针时，目的就是让这两个指针指向同一块内存空间，所以这里本就应该进行浅拷贝，但单纯的浅拷贝又会导致空间被多次释放，因此根据解决智能指针拷贝问题方式的不同，从而衍生出了不同版本的智能指针。

C++中的智能指针

std::auto_ptr

管理权转移

auto_ptr是C++98中引入的智能指针，auto_ptr通过管理权转移的方式解决智能指针的拷贝问题，保证一个资源在任何时刻都只有一个对象在对其进行管理，这时同一个资源就不会被多次释放了。比如：

int main()
{
    std::auto_ptr<int> ap1(new int(1));
    std::auto_ptr<int> ap2(ap1);
    *ap2 = 10;
    //*ap1 = 20; //error

    std::auto_ptr<int> ap3(new int(1));
    std::auto_ptr<int> ap4(new int(2));
    ap3 = ap4;
    return 0;
}

但一个对象的管理权转移后也就意味着，该对象不能再用对原来管理的资源进行访问了，否则程序就会崩溃，因此使用auto_ptr之前必须先了解它的机制，否则程序很容易出问题，很多公司也都明确规定了禁止使用auto_ptr。

auto_ptr的模拟实现

简易版的auto_ptr的实现步骤如下：

  1. 在构造函数中获取资源，在析构函数中释放资源，利用对象的生命周期来控制资源。
  2. 对*和->运算符进行重载，使auto_ptr对象具有指针一样的行为。
  3. 在拷贝构造函数中，用传入对象管理的资源来构造当前对象，并将传入对象管理资源的指针置空。
  4. 在拷贝赋值函数中，先将当前对象管理的资源释放，然后再接管传入对象管理的资源，最后将传入对象管理资源的指针置空。

代码如下：

namespace chr
{
    template<class T>
    class auto_ptr
    {
    public:
        //RAII
        auto_ptr(T* ptr = nullptr)
            :_ptr(ptr)
        {}
        ~auto_ptr()
        {
            if (_ptr != nullptr)
            {
                cout << "delete: " << _ptr << endl;
                delete _ptr;
                _ptr = nullptr;
            }
        }
        auto_ptr(auto_ptr<T>& ap)
            :_ptr(ap._ptr)
        {
            ap._ptr = nullptr; //管理权转移后ap被置空
        }
        auto_ptr& operator=(auto_ptr<T>& ap)
        {
            if (this != &ap)
            {
                delete _ptr;       //释放自己管理的资源
                _ptr = ap._ptr;    //接管ap对象的资源
                ap._ptr = nullptr; //管理权转移后ap被置空
            }
            return *this;
        }
        //可以像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }
        T* operator->()
        {
            return _ptr;
        }
    private:
        T* _ptr; //管理的资源
    };
}

std::unique_ptr

防拷贝

unique_ptr是C++11中引入的智能指针，unique_ptr通过防拷贝的方式解决智能指针的拷贝问题，也就是简单粗暴的防止对智能指针对象进行拷贝，这样也能保证资源不会被多次释放。比如：

int main()
{
    std::unique_ptr<int> up1(new int(0));
    //std::unique_ptr<int> up2(up1); //error
    return 0;
}

但防拷贝其实也不是一个很好的办法，因为总有一些场景需要进行拷贝。

unique_ptr的模拟实现

简易版的unique_ptr的实现步骤如下：

  1. 在构造函数中获取资源，在析构函数中释放资源，利用对象的生命周期来控制资源。
  2. 对*和->运算符进行重载，使unique_ptr对象具有指针一样的行为。
  3. 用C++98的方式将拷贝构造函数和拷贝赋值函数声明为私有，或者用C++11的方式在这两个函数后面加上=delete，防止外部调用。

代码如下：

namespace chr
{
    template<class T>
    class unique_ptr
    {
    public:
        //RAII
        unique_ptr(T* ptr = nullptr)
            :_ptr(ptr)
        {}
        ~unique_ptr()
        {
            if (_ptr != nullptr)
            {
                cout << "delete: " << _ptr << endl;
                delete _ptr;
                _ptr = nullptr;
            }
        }
        //可以像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }
        T* operator->()
        {
            return _ptr;
        }
        //防拷贝
        unique_ptr(unique_ptr<T>& up) = delete;
        unique_ptr& operator=(unique_ptr<T>& up) = delete;
    private:
        T* _ptr; //管理的资源
    };
}

std::shared_ptr

std::shared_ptr的基本设计

引用计数

shared_ptr是C++11中引入的智能指针，shared_ptr通过引用计数的方式解决智能指针的拷贝问题。

  • 每一个被管理的资源都有一个对应的引用计数，通过这个引用计数记录着当前有多少个对象在管理着这块资源。
  • 当新增一个对象管理这块资源时则将该资源对应的引用计数进行++，当一个对象不再管理这块资源或该对象被析构时则将该资源对应的引用计数进行–。
  • 当一个资源的引用计数减为0时说明已经没有对象在管理这块资源了，这时就可以将该资源进行释放了。

通过这种引用计数的方式就能支持多个对象一起管理某一个资源，也就是支持了智能指针的拷贝，并且只有当一个资源对应的引用计数减为0时才会释放资源，因此保证了同一个资源不会被释放多次。比如：

int main()
{
    cl::shared_ptr<int> sp1(new int(1));
    cl::shared_ptr<int> sp2(sp1);
    *sp1 = 10;
    *sp2 = 20;
    cout << sp1.use_count() << endl; //2

    cl::shared_ptr<int> sp3(new int(1));
    cl::shared_ptr<int> sp4(new int(2));
    sp3 = sp4;
    cout << sp3.use_count() << endl; //2
    return 0;
}

说明一下： use_count成员函数，用于获取当前对象管理的资源对应的引用计数。

shared_ptr的模拟实现

简易版的shared_ptr的实现步骤如下：

  1. 在shared_ptr类中增加一个成员变量count，表示智能指针对象管理的资源对应的引用计数。
  2. 在构造函数中获取资源，并将该资源对应的引用计数设置为1，表示当前只有一个对象在管理这个资源。
  3. 在拷贝构造函数中，与传入对象一起管理它管理的资源，同时将该资源对应的引用计数++。
  4. 在拷贝赋值函数中，先将当前对象管理的资源对应的引用计数–（如果减为0则需要释放），然后再与传入对象一起管理它管理的资源，同时需要将该资源对应的引用计数++。
  5. 在析构函数中，将管理资源对应的引用计数–，如果减为0则需要将该资源释放。
  6. 对*和->运算符进行重载，使shared_ptr对象具有指针一样的行为。

代码如下：

namespace chr
{
    template<class T>
    class shared_ptr
    {
    public:
        //RAII
        shared_ptr(T* ptr = nullptr)
            :_ptr(ptr)
            , _pcount(new int(1))
        {}
        ~shared_ptr()
        {
            if (--(*_pcount) == 0)
            {
                if (_ptr != nullptr)
                {
                    cout << "delete: " << _ptr << endl;
                    delete _ptr;
                    _ptr = nullptr;
                }
                delete _pcount;
                _pcount = nullptr;
            }
        }
        shared_ptr(shared_ptr<T>& sp)
            :_ptr(sp._ptr)
            , _pcount(sp._pcount)
        {
            (*_pcount)++;
        }
        shared_ptr& operator=(shared_ptr<T>& sp)
        {
            if (_ptr != sp._ptr) //管理同一块空间的对象之间无需进行赋值操作
            {
                if (--(*_pcount) == 0) //将管理的资源对应的引用计数--
                {
                    cout << "delete: " << _ptr << endl;
                    delete _ptr;
                    delete _pcount;
                }
                _ptr = sp._ptr;       //与sp对象一同管理它的资源
                _pcount = sp._pcount; //获取sp对象管理的资源对应的引用计数
                (*_pcount)++;         //新增一个对象来管理该资源，引用计数++
            }
            return *this;
        }
        //获取引用计数
        int use_count()
        {
            return *_pcount;
        }
        //可以像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }
        T* operator->()
        {
            return _ptr;
        }
    private:
        T* _ptr;      //管理的资源
        int* _pcount; //管理的资源对应的引用计数
    };
}

为什么引用计数需要存放在堆区？

首先，shared_ptr中的引用计数count不能单纯的定义成一个int类型的成员变量，因为这就意味着每个shared_ptr对象都有一个自己的count成员变量，而当多个对象要管理同一个资源时，这几个对象应该用到的是同一个引用计数。
image.png

其次，shared_ptr中的引用计数count也不能定义成一个静态的成员变量，因为静态成员变量是所有类型对象共享的，这会导致管理相同资源的对象和管理不同资源的对象用到的都是同一个引用计数。image.png
而如果将shared_ptr中的引用计数count定义成一个指针，当一个资源第一次被管理时就在堆区开辟一块空间用于存储其对应的引用计数，如果有其他对象也想要管理这个资源，那么除了将这个资源给它之外，还需要把这个引用计数也给它。

这时管理同一个资源的多个对象访问到的就是同一个引用计数，而管理不同资源的对象访问到的就是不同的引用计数了，相当于将各个资源与其对应的引用计数进行了绑定。
image.png

但同时需要注意，由于引用计数的内存空间也是在堆上开辟的，因此当一个资源对应的引用计数减为0时，除了需要将该资源释放，还需要将该资源对应的引用计数的内存空间进行释放。

std::shared_ptr的线程安全问题

shared_ptr的线程安全问题

当前模拟实现的shared_ptr还存在线程安全的问题，由于管理同一个资源的多个对象的引用计数是共享的，因此多个线程可能会同时对同一个引用计数进行自增或自减操作，而自增和自减操作都不是原子操作，因此需要通过加锁来对引用计数进行保护，否则就会导致线程安全问题。

比如下面代码中用一个shared_ptr管理一个整型变量，然后用两个线程分别对这个shared_ptr对象进行1000次拷贝操作，这些对象被拷贝出来后又会立即被销毁。比如：

void func(chr::shared_ptr<int>& sp, size_t n)
{
    for (size_t i = 0; i < n; i++)
    {
        cl::shared_ptr<int> copy(sp);
    }
}
int main()
{
    chr::shared_ptr<int> p(new int(0));

    const size_t n = 1000;
    thread t1(func, p, n);
    thread t2(func, p, n);

    t1.join();
    t2.join();

    cout << p.use_count() << endl; //预期：1

    return 0;
}

在这个过程中两个线程会不断对引用计数进行自增和自减操作，理论上最终两个线程执行完毕后引用计数的值应该是1，因为拷贝出来的对象都被销毁了，只剩下最初的shared_ptr对象还在管理这个整型变量，但每次运行程序得到引用计数的值可能都是不一样的，根本原因就是因为对引用计数的自增和自减不是原子操作。

加锁解决线程安全问题

要解决引用计数的线程安全问题，本质就是要让对引用计数的自增和自减操作变成一个原子操作，因此可以对引用计数的操作进行加锁保护，也可以用原子类atomic对引用计数进行封装，这里以加锁为例。

  • 在shared_ptr类中新增互斥锁成员变量，为了让管理同一个资源的多个线程访问到的是同一个互斥锁，管理不同资源的线程访问到的是不同的互斥锁，因此互斥锁也需要在堆区创建。

  • 在调用拷贝构造函数和拷贝赋值函数时，除了需要将对应的资源和引用计数交给当前对象管理之外，还需要将对应的互斥锁也交给当前对象。

  • 当一个资源对应的引用计数减为0时，除了需要将对应的资源和引用计数进行释放，由于互斥锁也是在堆区创建的，因此还需要将对应的互斥锁进行释放。

  • 为了简化代码逻辑，可以将拷贝构造函数和拷贝赋值函数中引用计数的自增操作提取出来，封装成AddRef函数，将拷贝赋值函数和析构函数中引用计数的自减操作提取出来，封装成ReleaseRef函数，这样就只需要对AddRef和ReleaseRef函数进行加锁保护即可。

    namespace chr
{
  template<class T>
  class shared_ptr
  {
  private:
      //++引用计数
      void AddRef()
      {
          _pmutex->lock();
          (*_pcount)++;
          _pmutex->unlock();
      }
      //--引用计数
      void ReleaseRef()
      {
          _pmutex->lock();
          bool flag = false;
          if (--(*_pcount) == 0) //将管理的资源对应的引用计数--
          {
              if (_ptr != nullptr)
              {
                  cout << "delete: " << _ptr << endl;
                  delete _ptr;
                  _ptr = nullptr;
              }
              delete _pcount;
              _pcount = nullptr;
              flag = true;
          }
          _pmutex->unlock();
          if (flag == true)
          {
              delete _pmutex;
          }
      }
  public:
      //RAII
      shared_ptr(T* ptr = nullptr)
          :_ptr(ptr)
          , _pcount(new int(1))
          , _pmutex(new mutex)
      {}
      ~shared_ptr()
      {
          ReleaseRef();
      }
      shared_ptr(shared_ptr<T>& sp)
          :_ptr(sp._ptr)
          , _pcount(sp._pcount)
          , _pmutex(sp._pmutex)
      {
          AddRef();
      }
      shared_ptr& operator=(shared_ptr<T>& sp)
      {
          if (_ptr != sp._ptr) //管理同一块空间的对象之间无需进行赋值操作
          {
              ReleaseRef();         //将管理的资源对应的引用计数--
              _ptr = sp._ptr;       //与sp对象一同管理它的资源
              _pcount = sp._pcount; //获取sp对象管理的资源对应的引用计数
              _pmutex = sp._pmutex; //获取sp对象管理的资源对应的互斥锁
              AddRef();             //新增一个对象来管理该资源，引用计数++
          }
          return *this;
      }
      //获取引用计数
      int use_count()
      {
          return *_pcount;
      }
      //可以像指针一样使用
      T& operator*()
      {
          return *_ptr;
      }
      T* operator->()
      {
          return _ptr;
      }
  private:
      T* _ptr;        //管理的资源
      int* _pcount;   //管理的资源对应的引用计数
      mutex* _pmutex; //管理的资源对应的互斥锁
  };
}


**说明一下：**

- 在ReleaseRef函数中，当引用计数被减为0时需要释放互斥锁资源，但不能在临界区中释放互斥锁，因为后面还需要进行解锁操作，因此代码中借助了一个flag变量，通过flag变量来判断解锁后释放需要释放互斥锁资源。
- shared_ptr只需要保证引用计数的线程安全问题，而不需要保证管理的资源的线程安全问题，就像原生指针管理一块内存空间一样，原生指针只需要指向这块空间，而这块空间的线程安全问题应该由这块空间的操作者来保证。


<a name="eJ1K3"></a>
#### std::shared_ptr的定制删除器
> 定制删除器的用法


当智能指针对象的生命周期结束时，所有的智能指针默认都是以delete的方式将资源释放，这是不太合适的，因为智能指针并不是只管理以new方式申请到的内存空间，智能指针管理的也可能是以new[]的方式申请到的空间，或管理的是一个文件指针。比如：
```cpp
struct ListNode
{
    ListNode* _next;
    ListNode* _prev;
    int _val;
    ~ListNode()
    {
        cout << "~ListNode()" << endl;
    }
};
int main()
{
    std::shared_ptr<ListNode> sp1(new ListNode[10]);   //error
    std::shared_ptr<FILE> sp2(fopen("test.cpp", "r")); //error

    return 0;
}

这时当智能指针对象的生命周期结束时，再以delete的方式释放管理的资源就会导致程序崩溃，因为以new[]的方式申请到的内存空间必须以delete[]的方式进行释放，而文件指针必须通过调用fclose函数进行释放。

这时就需要用到定制删除器来控制释放资源的方式，C++标准库中的shared_ptr提供了如下构造函数：

template <class U, class D>
shared_ptr (U* p, D del);

参数说明：

  • p：需要让智能指针管理的资源。
  • del：删除器，这个删除器是一个可调用对象，比如函数指针、仿函数、lambda表达式以及被包装器包装后的可调用对象。

当shared_ptr对象的生命周期结束时就会调用传入的删除器完成资源的释放，调用该删除器时会将shared_ptr管理的资源作为参数进行传入。

因此当智能指针管理的资源不是以new的方式申请到的内存空间时，就需要在构造智能指针对象时传入定制的删除器。比如：

template<class T>
struct DelArr
{
    void operator()(const T* ptr)
    {
        cout << "delete[]: " << ptr << endl;
        delete[] ptr;
    }
};
int main()
{
    std::shared_ptr<ListNode> sp1(new ListNode[10], DelArr<ListNode>());
    std::shared_ptr<FILE> sp2(fopen("test.cpp", "r"), [](FILE* ptr){
        cout << "fclose: " << ptr << endl;
        fclose(ptr);
    });

    return 0;
}

定制删除器的模拟实现

定制删除器的实现问题：

  • C++标准库中实现shared_ptr时是分成了很多个类的，因此C++标准库中可以将删除器的类型设置为构造函数的模板参数，然后将删除器的类型在各个类之间进行传递。

  • 但我们是直接用一个类来模拟实现shared_ptr的，因此不能将删除器的类型设置为构造函数的模板参数。因为删除器不是在构造函数中调用的，而是需要在ReleaseRef函数中进行调用，因此势必需要用一个成员变量将删除器保存下来，而在定义这个成员变量时就需要指定删除器的类型，因此这里模拟实现的时候不能将删除器的类型设置为构造函数的模板参数。

  • 要在当前模拟实现的shared_ptr的基础上支持定制删除器，就只能给shared_ptr类再增加一个模板参数，在构造shared_ptr对象时就需要指定删除器的类型。然后增加一个支持传入删除器的构造函数，在构造对象时将删除器保存下来，在需要释放资源的时候调用该删除器进行释放即可。最好在设置一个默认的删除器，如果用户定义shared_ptr对象时不传入删除器，则默认以delete的方式释放资源。

    namespace chr
{
  //默认的删除器
  template<class T>
  struct Delete
  {
      void operator()(const T* ptr)
      {
          delete ptr;
      }
  };
  template<class T, class D = Delete<T>>
  class shared_ptr
  {
  private:
      void ReleaseRef()
      {
          _pmutex->lock();
          bool flag = false;
          if (--(*_pcount) == 0) //将管理的资源对应的引用计数--
          {
              if (_ptr != nullptr)
              {
                  cout << "delete: " << _ptr << endl;
                  _del(_ptr); //使用定制删除器释放资源
                  _ptr = nullptr;
              }
              delete _pcount;
              _pcount = nullptr;
              flag = true;
          }
          _pmutex->unlock();
          if (flag == true)
          {
              delete _pmutex;
          }
      }
      //...
  public:
      shared_ptr(T* ptr, D del)
          : _ptr(ptr)
          , _pcount(new int(1))
          , _pmutex(new mutex)
          , _del(del)
      {}
      //...
  private:
      T* _ptr;        //管理的资源
      int* _pcount;   //管理的资源对应的引用计数
      mutex* _pmutex; //管理的资源对应的互斥锁
      D _del;         //管理的资源对应的删除器
  };
}

这时我们模拟实现的shared_ptr就支持定制删除器了，但是使用起来没有C++标准库中的那么方便。

  • 如果传入的删除器是一个仿函数，那么需要在构造shared_ptr对象时指明仿函数的类型。

  • 如果传入的删除器是一个lambda表达式就更麻烦了，因为lambda表达式的类型不太容易获取。这里可以将lambda表达式的类型指明为一个包装器类型，让编译器传参时自行进行推演，也可以先用auto接收lambda表达式，然后再用decltype来声明删除器的类型

    template<class T>
struct DelArr
{
  void operator()(const T* ptr)
  {
      cout << "delete[]: " << ptr << endl;
      delete[] ptr;
  }
};
int main()
{
  //仿函数示例
  chr::shared_ptr<ListNode, DelArr<ListNode>> sp1(new ListNode[10], DelArr<ListNode>());

  //lambda示例1
  chr::shared_ptr<FILE, function<void(FILE*)>> sp2(fopen("test.cpp", "r"), [](FILE* ptr){
      cout << "fclose: " << ptr << endl;
      fclose(ptr);
  });

  //lambda示例2
  auto f = [](FILE* ptr){
      cout << "fclose: " << ptr << endl;
      fclose(ptr);
  };
  chr::shared_ptr<FILE, decltype(f)> sp3(fopen("test.cpp", "r"), f);

  return 0;
}

std::weak_ptr

std::shared_ptr的循环引用问题

循环引用问题

shared_ptr的循环引用问题在一些特定的场景下才会产生。比如定义如下的结点类，并在结点类的析构函数中打印一句提示语句，便于判断结点是否正确释放。

struct ListNode
{
    ListNode* _next;
    ListNode* _prev;
    int _val;
    ~ListNode()
    {
        cout << "~ListNode()" << endl;
    }
};

现在以new的方式在堆上构建两个结点，并将这两个结点连接起来，在程序的最后以delete的方式释放这两个结点。比如：

int main()
{
    ListNode* node1 = new ListNode;
    ListNode* node2 = new ListNode;

    node1->_next = node2;
    node2->_prev = node1;
    //...
    delete node1;
    delete node2;
    return 0;
}

上述程序是没有问题的，两个结点都能够正确释放。为了防止程序中途返回或抛异常等原因导致结点未被释放，我们将这两个结点分别交给两个shared_ptr对象进行管理，这时为了让连接节点时的赋值操作能够执行，就需要把ListNode类中的next和prev成员变量的类型也改为shared_ptr类型。比如：

struct ListNode
{
    std::shared_ptr<ListNode> _next;
    std::shared_ptr<ListNode> _prev;
    int _val;
    ~ListNode()
    {
        cout << "~ListNode()" << endl;
    }
};
int main()
{
    std::shared_ptr<ListNode> node1(new ListNode);
    std::shared_ptr<ListNode> node2(new ListNode);

    node1->_next = node2;
    node2->_prev = node1;
    //...

    return 0;
}

这时程序运行结束后两个结点都没有被释放，但如果去掉连接结点时的两句代码中的任意一句，那么这两个结点就都能够正确释放，根本原因就是因为这两句连接结点的代码导致了循环引用。

当以new的方式申请到两个ListNode结点并交给两个智能指针管理后，这两个资源对应的引用计数都被加到了1。如下图：
image.png

将这两个结点连接起来后，资源1当中的next成员与node2一同管理资源2，资源2中的prev成员与node1一同管理资源1，此时这两个资源对应的引用计数都被加到了2。如下图：image.png

当出了main函数的作用域后，node1和node2的生命周期也就结束了，因此这两个资源对应的引用计数最终都减到了1。如下图：image.png

循环引用导致资源未被释放的原因：

  • 当资源对应的引用计数减为0时对应的资源才会被释放，因此资源1的释放取决于资源2当中的prev成员，而资源2的释放取决于资源1当中的next成员。
  • 而资源1当中的next成员的释放又取决于资源1，资源2当中的prev成员的释放又取决于资源2，于是这就变成了一个死循环，最终导致资源无法释放。

而如果连接结点时只进行一个连接操作，那么当node1和node2的生命周期结束时，就会有一个资源对应的引用计数被减为0，此时这个资源就会被释放，这个释放后另一个资源的引用计数也会被减为0，最终两个资源就都被释放了，这就是为什么只进行一个连接操作时这两个结点就都能够正确释放的原因。

std::weak_ptr解决循环引用问题

解决循环引用问题

weak_ptr是C++11中引入的智能指针，weak_ptr不是用来管理资源的释放的，它主要是用来解决shared_ptr的循环引用问题的。

  • weak_ptr支持用shared_ptr对象来构造weak_ptr对象，构造出来的weak_ptr对象与shared_ptr对象管理同一个资源，但不会增加这块资源对应的引用计数。

将ListNode中的next和prev成员的类型换成weak_ptr就不会导致循环引用问题了，此时当node1和node2生命周期结束时两个资源对应的引用计数就都会被减为0，进而释放这两个结点的资源。比如：

struct ListNode
{
    std::weak_ptr<ListNode> _next;
    std::weak_ptr<ListNode> _prev;
    int _val;
    ~ListNode()
    {
        cout << "~ListNode()" << endl;
    }
};
int main()
{
    std::shared_ptr<ListNode> node1(new ListNode);
    std::shared_ptr<ListNode> node2(new ListNode);

    cout << node1.use_count() << endl;
    cout << node2.use_count() << endl;
    node1->_next = node2;
    node2->_prev = node1;
    //...
    cout << node1.use_count() << endl;
    cout << node2.use_count() << endl;
    return 0;
}

通过use_count获取这两个资源对应的引用计数就会发现，在结点连接前后这两个资源对应的引用计数就是1，根本原因就是weak_ptr不会增加管理的资源对应的引用计数。

weak_ptr的模拟实现

简易版的weak_ptr的实现步骤如下：

  1. 提供一个无参的构造函数，比如刚才new ListNode时就会调用weak_ptr的无参的构造函数。

  2. 支持用shared_ptr对象拷贝构造weak_ptr对象，构造时获取shared_ptr对象管理的资源。

  3. 支持用shared_ptr对象拷贝赋值给weak_ptr对象，赋值时获取shared_ptr对象管理的资源。

  4. 对*和->运算符进行重载，使weak_ptr对象具有指针一样的行为。

    namespace chr
{
 template<class T>
 class weak_ptr
 {
 public:
     weak_ptr()
         :_ptr(nullptr)
     {}
     weak_ptr(const shared_ptr<T>& sp)
         :_ptr(sp.get())
     {}
     weak_ptr& operator=(const shared_ptr<T>& sp)
     {
         _ptr = sp.get();
         return *this;
     }
     //可以像指针一样使用
     T& operator*()
     {
         return *_ptr;
     }
     T* operator->()
     {
         return _ptr;
     }
 private:
     T* _ptr; //管理的资源
 };
}

    说明一下： shared_ptr还会提供一个get函数，用于获取其管理的资源。

C++11和boost中智能指针的关系

  • C++98中产生了第一个智能指针auto_ptr。
  • C++boost给出了更实用的scoped_ptr、shared_ptr和weak_ptr。
  • C++TR1，引入了boost中的shared_ptr等。不过注意的是TR1并不是标准版。
  • C++11，引入了boost中的unique_ptr、shared_ptr和weak_ptr。需要注意的是，unique_ptr对应的就是boost中的scoped_ptr，并且这些智能指针的实现原理是参考boost中实现的。

说明一下：boost库是为C++语言标准库提供扩展的一些C++程序库的总称，boost库社区建立的初衷之一就是为C++的标准化工作提供可供参考的实现，比如在送审C++标准库TR1中，就有十个boost库成为标准库的候选方案。

裙下的霸气
关注
专栏目录
C++ 智能指针 - 全部用法详解
cpp_learner的博客
08-02 8万+
血的教训？不学智能指针，本人丢了一份工作。
C++智能指针详解
qq_61635026的博客
10-02 2058
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
C++ 智能指针
weixin_54670782的博客
12-01 3872
智能指针 输入问题： 给定一个字符串，不知道有几个字符，怎样输入？ 使用cin.getline(); 输入一行。 智能指针概念 智能指针主要是针对裸指针进行了一次面向对象的封装，在构造函数中初始化资源地址，在析构函数中释放资源。当资源应该被释放时，指向它的智能指针可以确保自动释放它。 RAII RAII 对堆上空间进行自动化管理——利用对象自动析构的机制。 malloc， new 等动态分配的对象，很有可能忘记了去释放资源而导致泄露。 对于一个对象而言，在构造函数的时候申请空间，而在析构函数（在离开
c++智能指针详解
热门推荐
bitcarmanlee的博客
05-18 3万+
1.什么是智能指针 从比较简单的层面来看，智能指针是RAII(Resource Acquisition Is Initialization，资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。 在c++中，智能指针一共定义了4种： auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中，auto_ptr 在 C++11已被摒弃，在C++17中已经移除不可用。 2.原始指针的问题 原始指
【C++进阶学习】第十三弹——C++智能指针的深入解析
2301_80220607的博客
08-13 2780
【C++进阶学习】：C++掌握内存管理重要一步——智能指针的深入解析：什么是智能指针？为什么需要智能指针？一篇带你搞清楚智能指针的作用及原理
C++智能指针基础用法详解
mahuifa的博客
04-21 1342
智能指针是C++中用于管理动态分配资源的强大工具，通过正确使用智能指针，可以显著减少内存泄漏的可能性，并提高代码的安全性和可维护性。
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 187
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 869
书生浦语大模型实战营第四期：Linux前置基础
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2209
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 33
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 693
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1142
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C++ -- 模板进阶
最新发布
zy1215058242的博客
11-02 536
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
C++智能指针实例详解：内存管理神器
C++智能指针实例详解深入解析了C++编程中解决内存管理问题的关键工具。C++语言原生缺乏自动内存回收功能，导致程序员在使用new分配内存后必须手动调用delete来释放，这易引发内存泄漏或因异常而未释放内存的问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

裙下的霸气

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值