C++之智能指针-阿里云开发者社区

一、智能指针的引入

C++11为什么要加入智能指针呢？我们为什么需要智能指针呢？

基于上面的问题，我们先来看一看下面的代码：

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

那么这里就有一个思考了：如果div调用这里抛异常会如何？我们首先来看看内存泄漏的概念：

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

内存泄漏的本质：指针丢了。失去了对该段内存的控制。

再回到上面的问题：如果div调用这里抛异常，程序就会直接跳到catch位置对异常进行捕获。而一旦直接跳到那个位置后就出现了问题： Func中的 delete p1 和 delete p2 操作就不会执行，p1和p2的空间就不会释放。那么这样就发生了内存泄漏。为了解决这个问题，我们可以在Func中捕获异常，然后delete掉p1和p2，接着再重新抛出异常。

这个问题看似是解决了，但是如果我们有很多个变量呢？我们不知道哪个会抛异常，所以我们需要考虑多种情况，而一旦情况考虑不充分就会发生内存泄漏，这样就很麻烦了。而这时我们就可以使用智能指针来帮助我们。

二、智能指针的原理及使用

1、RAII思想

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

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

1、不需要显式地释放资源。

2、采用这种方式，对象所需的资源在其生命期内始终保持有效。

使用RAII思想设计的SmartPtr类：

template<class T>
class SmartPtr 
{
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}
    ~SmartPtr()
    {
        if(_ptr)
        delete _ptr;
    }
private:
    T* _ptr;
}；

2、智能指针的原理

所谓智能指针，它的本质就需要像一个指针一样去使用。上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。我们还得需要将* 、->重载下，才可让其像指针一样去使用。

template<class T>
class SmartPtr
{
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}
    ~SmartPtr()
    {
        if(_ptr)
            delete _ptr;
    }
    T& operator*() 
    {
        return *_ptr;
    }
    T* operator->() 
    {
        return _ptr;
    }
private:
    T* _ptr;
};

3、智能指针的使用

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

使用了智能指针后，在Func中，即使div的调用抛出了异常，直接跳到了catch位置，sp1和sp2的空间也能够释放。因为在Func栈帧结束后，sp1和sp2会去自动调用析构函数，释放空间。这就是智能指针的作用。

三、智能指针的拷贝问题

我们还是使用上面设计的智能指针：

template<class T>
class SmartPtr
{
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}
    ~SmartPtr()
    {
        if(_ptr)
            delete _ptr;
    }
    T& operator*() 
    {
        return *_ptr;
    }
    T* operator->() 
    {
        return _ptr;
    }
private:
    T* _ptr;
};

如果我们执行下面的程序会发生什么呢？

class A
{
public:
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a1;
    int _a2;
};
int main()
{
  SmartPtr<A> p1(new A);
  SmartPtr<A> p2(p1);
    return 0;
}

答案当然是程序崩溃。为什么呢？因为我们没有实现拷贝构造，所以编译器会调用默认的拷贝构造函数，这样p1和p1会指向同一块空间，会被析构两次。这个问题不是很好解决吗！根据我们以前的经验，我们只需要实现深拷贝就可以解决这个问题了。

但是，让智能指针实现深拷贝是万万不可的。因为智能指针在本质上是个指针，而我们知道一个指针赋值给另一个指针，那么它们将会管理同一块空间，这是一定的。所以两个智能指针指向同一块空间是正确的，它们就是要管理同一块空间。我们就是需要浅拷贝，而不是深拷贝。

那么我们应该怎么解决对象析构两次的问题呢？下面我们根据标准库中的智能指针来看看解决方法。

四、标准库中的智能指针

1、auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。

class A
{
public:
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a1;
    int _a2;
};
int main()
{
    auto_ptr<A> p1(new A);
    return 0;
}

我们发现我们根本不需要去亲自 delete 掉 new出来的空间，出了作用域后会自动释放。

auto_ptr解决拷贝问题的方式：

auto_ptr<A> p1(new A);
auto_ptr<A> p2(p1);

我们发现 auto_ptr 解决这个问题的方式就是简单粗暴地将管理权限进行了转移。让p2来管理这块空间，p1不再管理这块空间了。这种拷贝方式是极其不负责任地。因为 auto_ptr有这样的问题，所以在实际应用中我们不会使用它。

模拟实现：

template<class T>
  class auto_ptr
  {
  public:
    auto_ptr(T* ptr)
      :_ptr(ptr)
    {}
    // 释放资源
    ~auto_ptr()
    {
            if(_ptr)
          delete _ptr;
    }
    auto_ptr(auto_ptr<T>& ap)
      :_ptr(ap._ptr)
    {
      ap._ptr = nullptr;
    }
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return return _ptr;
    }
  private:
    T* _ptr;
  };

2、unique_ptr

unique_ptr就是一个不能进行拷贝的智能指针，实现原理：简单粗暴的防拷贝。

模拟实现：

template<class T>
  class unique_ptr
  {
  public:
    unique_ptr(T* ptr)
      :_ptr(ptr)
    {}
    ~unique_ptr()
    {
            if(_ptr)
          delete _ptr;
    }
    unique_ptr(const unique_ptr<T>& up) = delete;
    unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return return _ptr;
    }
  private:
    T* _ptr;
  };

3、shared_ptr

C++11中开始提供支持拷贝的shared_ptr智能指针。shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

1、 shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共

享。

2、在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减

一。

3、如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源。

4、如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

注：引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源。

class A
{
public:
    ~A()
    {
        cout << "~A()" << endl;
    }
  int _a1 = 1;
  int _a2 = 2;
};
int main()
{
  shared_ptr<A> p1(new A);
  shared_ptr<A> p2(p1);
  cout << p1->_a1++ << endl;
  cout << p2->_a1++ << endl;
    return 0;
}

从上面的运行结果中，我们知道了p1和p2共同管理了同一块空间。

~ 模拟实现

template<class T>
  class shared_ptr
  {
  public:
    shared_ptr(T* ptr)
      :_ptr(ptr)
      , _pcount(new int(1))
    {}
    ~shared_ptr()
    {
      Release();
    }
    shared_ptr(const shared_ptr<T>& sp)
      :_ptr(sp._ptr)
      , _pcount(sp._pcount)
    {
      ++(*_pcount);
    }
    void Release()
    {
      if (--(*_pcount) == 0)
      {
        delete _pcount;
        delete _ptr;
      }
    }
    shared_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
      if (_ptr != sp._ptr)
      {
        Release();
        _pcount = sp._pcount;
        _ptr = sp._ptr;
        ++(*_pcount);
      }
      return *this;
    }
        int use_count()
    {
      return *_pcount;
    }
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return _ptr;
    }
  private:
    T* _ptr;
    int* _pcount;
  };

~ shared_ptr循环引用问题

我们先来看看下面的情况：

struct Node
{
  int _val;
  shared_ptr<Node> _next;
  shared_ptr<Node> _prev;
  ~Node()
  {
    cout << "~Node()" << endl;
  }
};
int main()
{
  shared_ptr<Node> n1(new Node);
  shared_ptr<Node> n2(new Node);
  n1->_next = n2;
  n2->_prev = n1;
    return 0;
}

上面的代码运行后，new出来的空间不能正常释放。这是为什么呢？请看下图：

_next作为左边节点的成员变量，只有当左边的节点被delete后，_next才能被析构。又因为_next管理着右边的节点，所以只有_next释放后，右边的节点才能释放。

而_prev又管理着左边的节点，只有_prev释放后，左边的节点才能释放，但是，_prev作为右边节点的成员变量，只有当右边的节点被delete后，_prev才能被析构。而前面也分析过了，右边的节点被_next管理着。

这就是shared_ptr的循环引用问题。那么我们应该怎么解决这个问题呢？这就需要用到我们后面讲的 weak_ptr了。

~ 定制删除器

智能指针实例化的对象在其生命周期结束时，默认是以delete的方式将空间释放，这是不太合适的，因为我们并不是只是以new的方式申请到的内存空间，也可能是以new[]的方式申请到多个空间，或是一个文件指针。如果我们仍像之前那样使用的话程序可能报错。如下代码程序会报错：

struct Node
{
  int _val;
  Node* _next;
  Node* _prev;
  ~Node()
  {
    cout << "~Node()" << endl;
  }
};
int main()
{
  shared_ptr<Node> sp(new Node[5]);
  return 0;
}

nwe[]申请内存空间必须以delete[]方式进行释放。这时我们需要通过定制删除器来控制资源的释放。

shared_ptr的构造函数：

shared_ptr允许在构造函数的位置传入定制删除器。

template <class T>
struct DeleteArray
{
  void operator()(const T* ptr)
  {
    delete[] ptr;
    cout << "delete []" << ptr << endl;
  }
};
int main()
{
    shared_ptr<int> sp1(new int);
    //在构造函数位置传入定制删除器
  shared_ptr<int> sp2(new int[10], DeleteArray<int>());
  return 0;
}

4、weak_ptr

weak_ptr不是常规的智能指针，它没有RAII，不支持直接管理资源。它主要用shared_ptr来构造，用来解决shared_ptr的循环引用的问题。

struct Node
{
  int _val;
  weak_ptr<Node> _next;
  weak_ptr<Node> _prev;
  ~Node()
  {
    cout << "~Node()" << endl;
  }
};
int main()
{
  shared_ptr<Node> n1(new Node);
  shared_ptr<Node> n2(new Node);
  n1->_next = n2;
  n2->_prev = n1;
    return 0;
}

_next 和 _prev 是 weak_ptr 时，它不参与资源的释放管理，但是可以访问和修改资源，且不增加计数，不存在循环引用的问题。

模拟实现：

template <class T>
  class weak_ptr
  {
  public:
    weak_ptr()
      :_ptr(nullptr)
    {}
    weak_ptr(const shared_ptr<T>& sp)
      :_ptr(sp._ptr)
    {}
        weak_ptr(const weak_ptr<T>& wp)
      :_ptr(wp._ptr)
    {}
        weak_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
      _ptr = sp._ptr;
      return *this;
        }
        T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return _ptr;
    }
  private:
    T* _ptr;
  };

C++之智能指针

一、智能指针的引入

二、智能指针的原理及使用

1、RAII思想

2、智能指针的原理

3、智能指针的使用

三、智能指针的拷贝问题

四、标准库中的智能指针

1、auto_ptr

2、unique_ptr

3、shared_ptr

~ 模拟实现

~ shared_ptr循环引用问题

~ 定制删除器

4、weak_ptr

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C++之智能指针

一、智能指针的引入

二、智能指针的原理及使用

1、RAII思想

2、智能指针的原理

3、智能指针的使用

三、智能指针的拷贝问题

四、标准库中的智能指针

1、auto_ptr

2、unique_ptr

3、shared_ptr

~ 模拟实现

~ shared_ptr循环引用问题

~ 定制删除器

4、weak_ptr

热门文章

最新文章

相关课程

相关电子书