浅剖智能指针----auto_ptr

最新推荐文章于 2021-12-01 20:59:35 发布

SmartBrave

最新推荐文章于 2021-12-01 20:59:35 发布

阅读量504

点赞数

分类专栏： C-C++

本文链接：https://blog.csdn.net/SmartBrave/article/details/52183787

版权

C-C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

刚刚在复习的时候遇到了智能指针，就一时兴起去找出了智能指针的源码看了看，现将我对auto_ptr的理解记录如下：
Linux下，auto_ptr源码在/usr/include/c++/4.4.7/backword/auto_ptr.h

auto_ptr本身是一个模板类，封装了一个原生指针。它最大的特点是在拷贝构造、赋值、传参等过程中对原生指针控制权的转移，即会将自己所管理的指针release掉，并赋给新的auto_ptr对象。

代码如下：

#ifndef _BACKWARD_AUTO_PTR_H
#define _BACKWARD_AUTO_PTR_H 1

#include <bits/c++config.h>
#include <debug/debug.h>

_GLIBCXX_BEGIN_NAMESPACE(std)

  template<typename _Tp1>
    struct auto_ptr_ref
    {
      _Tp1* _M_ptr;

      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
    } _GLIBCXX_DEPRECATED_ATTR;

  template<typename _Tp>
    class auto_ptr
    {
    private:
      _Tp* _M_ptr;

    public:
      typedef _Tp element_type;

      explicit
      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }

      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }

      template<typename _Tp1>
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }

      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
    reset(__a.release());
    return *this;
      }

      template<typename _Tp1>
        auto_ptr&
        operator=(auto_ptr<_Tp1>& __a) throw()
        {
      reset(__a.release());
      return *this;
    }

      ~auto_ptr() { delete _M_ptr; }

      element_type&
      operator*() const throw() 
      {
    _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
    return *_M_ptr; 
      }

      element_type*
      operator->() const throw() 
      {
    _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
    return _M_ptr; 
      }

      element_type*
      get() const throw() { return _M_ptr; }

      element_type*
      release() throw()
      {
    element_type* __tmp = _M_ptr;
    _M_ptr = 0;
    return __tmp;
      }

      void
      reset(element_type* __p = 0) throw()
      {
    if (__p != _M_ptr)
      {
        delete _M_ptr;
        _M_ptr = __p;
      }
      }

      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
      : _M_ptr(__ref._M_ptr) { }

      auto_ptr&
      operator=(auto_ptr_ref<element_type> __ref) throw()
      {
    if (__ref._M_ptr != this->get())
      {
        delete _M_ptr;
        _M_ptr = __ref._M_ptr;
      }
    return *this;
      }

      template<typename _Tp1>
        operator auto_ptr_ref<_Tp1>() throw()
        { return auto_ptr_ref<_Tp1>(this->release()); }

      template<typename _Tp1>
        operator auto_ptr<_Tp1>() throw()
        { return auto_ptr<_Tp1>(this->release()); }
    } _GLIBCXX_DEPRECATED_ATTR;

  template<>
    class auto_ptr<void>
    {
    public:
      typedef void element_type;
    } _GLIBCXX_DEPRECATED_ATTR;

_GLIBCXX_END_NAMESPACE

#endif /* _BACKWARD_AUTO_PTR_H */