【C++】智能指针的原始写法、scoped写法、shared写法

原创 2016年05月30日 15:04:24

  智能指针的三种常见写法:

  一、最开始的原始写法,原始写法可以理解为指针转移的方法。

template<typename T>
class AutoPtr
{
public:
    AutoPtr()
        :_ptr(NULL)
    {}

    AutoPtr(T* ptr)
        :_ptr(ptr)
    {}

    ~AutoPtr()
    {
        if (_ptr)
        {
            delete _ptr;
            _ptr = NULL;
        }
    }

    AutoPtr<T>(AutoPtr<T>& ap)
        : _ptr(ap._ptr)
    {
        ap._ptr = NULL;
    }

    AutoPtr<T>& operator = (AutoPtr<T>& ap)
    {
        if (this != &ap)
        {
            delete _ptr;
            _ptr = ap._ptr;
            ap._ptr = NULL;
        }

        return *this;
    }


    T& operator*()
    {
        return *_ptr;

    }

    T* GerPtr()
    {
        return _ptr;
    }
private:
    T* _ptr;
};

  二、演变为后来的scoped写法,又可以称作守卫写法。该写法相对于原始写法的优点在于不让使用拷贝构造和运算符的重载,这样就避免了深浅拷贝的指针问题。做法是把拷贝构造、运算符的重载定声明出来而不定义,并且用protected保护起来。scoped写法是引用的boost库。有兴趣的可以去了解一下这个东西,背后还是有很多故事的,在这我就不多说啦。

template<class T>
class scopedPtr
{
public:
    scopedPtr()
        :_ptr(NULL)
    {}

    scopedPtr(T* ptr)
        :_ptr(ptr)
    {}

    ~scopedPtr()
    {
        if (_ptr)
        {
            delete _ptr;
            _ptr = NULL;
        }
    }
    
    T& operator*()
    {
        return *_ptr;
    }

    T* operator->()
    {
        return _ptr;
    }

    T* GetPtr()
    {
        return _ptr;
    }

protected: //加上protected可以防止使用者在类之外定义拷贝构造和运算符的重载函数
    scopedPtr<T>(const scopedPtr<T>& sp);        //不让使用者使用拷贝,可以防止拷贝,所以只声明不定义
    scopedPtr<T>& operator=(const scopedPtr<T>& sp);

private:
    T* _ptr;
};

  三、sharedPtr写法

这种方法考虑了深浅拷贝问题并且引用了引用计数器来解决浅拷贝的问题,比较完善的实现了智能指针想要实现的功能。

template<class T>
class SharePtr
{
public:
    SharePtr(T* ptr)
        :_ptr(ptr)
        , _pCount(new int(1))
    {}

    //SharePtr(Shar)
    //    :_ptr(sp._ptr)
    //{
    //    *_pCount = 1;
    //}

    ~SharePtr()
    {
        if (_ptr)
        {
            if (--(*_pCount) == 0)
            {
                delete _ptr;
                delete _pCount;
                _ptr = NULL;
                _pCount = NULL;
            }

            _ptr = NULL;
        }
    }

    SharePtr<T>(const SharePtr<T>& sp)
    {
        _ptr = sp._ptr;
        _pCount = sp._pCount;
        ++(*_pCount);
    }

    SharePtr<T>& operator=(const SharePtr<T>& sp)
    {
        if (this != &sp)
        {
            if (--(*_pCount) == 0)    //这里要分清楚是谁减一,逻辑需要分析清楚
            {
                delete _ptr;
                delete _pCount;
                _ptr = NULL;
                _pCount = NULL;
            }

            _ptr = sp._ptr;
            _pCount = sp._pCount;
            ++(*_pCount);
        }
        return *this;
    }

private:
    T* _ptr;
    int* _pCount;
};


本文出自 “滴水” 博客,请务必保留此出处http://10740329.blog.51cto.com/10730329/1766046

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

详解C++各种智能指针: auto_ptr, shared_ptr, weak_ptr, scoped_ptr

C++ 中经常被问到的一个问题就是如何分辨各种智能指针。  先归纳起来做一个综合的比较:  auto_ptr auto_ptr是现在标准库里面一个轻量级的智能指针的实现,存在于头文件 mem...

c++智能指针:boost::scoped_ptr,boost::shared_ptr,boost::scoped_array

boost::scoped_ptr使用示例:#include #include #include using namespace std; class TestBody { public: ...

智能指针——auto_ptr、shared_ptr、weak_ptr、scoped_ptr

一句话总结: 1、auto_ptr 能够拷贝,能够转移所有权 2、scoped_ptr  不能拷贝,不能转移所有权 #include #include #include ...

浅析Boost智能指针:scoped_ptr shared_ptr weak_ptr

虽然通过弱引用指针可以有效的解除循环引用,但这种方式必须在程序员能预见会出现循环引用的情况下才能使用,也可以是说这个仅仅是一种编译期的解决方案,如果程序在运行过程中出现了循环引用,还是会造成内存泄漏的...
  • kxywn
  • kxywn
  • 2015年05月16日 14:45
  • 290

boost库:智能指针(auto_ptr、scoped_ptr、shared_ptr)浅谈

无论C还是C++中,我们从一开始接触他们,老时就开始强调在使用后要对内存进行释放,以免发生内存泄露,但是,我们总有粗心的时候,C++中提出了只能指针的概念,用只能指针类来管理所申请的内存,伴随着函数的...

详解Boost库智能指针(shared_ptr && scoped_ptr && weak_ptr )

我们先来解释一下什么叫智能指针? 智能指针是利用RAII(在对象的构造函数中执行资源的获取(指针的初始化),在析构函数中释放(delete 指针):这种技法把它称之为RAII(Resource Ac...
  • NK_test
  • NK_test
  • 2016年01月30日 10:53
  • 2230

Boost智能指针——scoped_ptr和shared_ptr

Boost智能指针——scoped_ptr boost::scoped_ptr和std::auto_ptr非常类似,是一个简单的智能指针,它能够保证在离开作用域后对象被自动释放。下列代码演示...
  • maweiqi
  • maweiqi
  • 2012年08月21日 10:21
  • 4050

智能指针scoped_ptr,shared_ptr,weak_ptr和auto_ptr的使用

通常在类中含有指针的话,需要对赋值操作符和拷贝构造函数进行重新定义,然而这些会引起一些歧义和不便,简单来说,赋值操作符是将原内存区的地址赋给新对象还是令新对象开辟新的内存区,再把原内存区的值赋值到新内...
  • tinyway
  • tinyway
  • 2014年02月18日 21:32
  • 399

智能指针shared_ptr的用法

源文章链接:http://www.cnblogs.com/jiayayao/archive/2016/12/03/6128877.html 为了解决C++内存泄漏的问题,C++11引入了智能指针(S...
  • TopsLuo
  • TopsLuo
  • 2017年07月18日 14:03
  • 123
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【C++】智能指针的原始写法、scoped写法、shared写法
举报原因:
原因补充:

(最多只允许输入30个字)