【C++】智能指针的作用,模拟实现auto_ptr,scoped_ptr,shared_ptr,scoped_array,shared_array

原创 2016年05月30日 17:18:19

RAII(Resource Acquisition Is Initialization):


资源分配即初始化,定义封装一个类,用来实现调用构造函数时就可完成资源的分配和初始化,在调用析构函数就可完成资源的清理,以实现对资源的初始化和清理。


智能指针:


用自动化或者说智能的指针来实现对动态内存的释放。

它是一个类,有类似指针的功能。


常见的智能指针有:auto_ptr/scoped_ptr/scoped_array/shared_ptr/shared_array


一、AutoPtr

首先,先介绍AutoPtr,为防止一块空间释放两次浅拷贝导致的崩溃情况,我们的思想是权限转移,就是说你拷贝时要将你的两个指针指向同一块空间,可是这样会程序崩溃。解决如下:


1)老版AutoPtr

主要变量是_ptr,_owner,用bool型的_owner来控制权限转移,当它为false值时释放空间,保证释放一次。

#include<iostream>
using namespace std;

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* ptr = NULL)
        :_ptr(ptr)
        , _owner(true)
    {}

    AutoPtr(const AutoPtr<T>& ap)
        :_ptr(ap._ptr)
    {
        ap._owner = false;
        _owner = true;
    }

    AutoPtr<T>& operator=(const AutoPtr<T>& ap)
    {
        if (&s != this)
        {
            delete _ptr;
            _ptr = ap._ptr;
            ap._owner = false;
            _owner = true;
        }
        return *this;
    }

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

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

    T& operator*()
    {
        return *_ptr;
    }
private:
    T* _ptr;
    bool _owner;
};

void Test()
{
    AutoPtr<int> ap1(new int(1));
    AutoPtr<int> ap2(ap1);
    AutoPtr<int> ap3 = ap1;
}

int main()
{
    Test();
    system("pause");
    return 0;
}


缺陷:

if(……)
{
     AutoPtr<int> ap2(ap1);
     ……
}

出了作用域后ap2会释放空间还给系统,而ap2仍指向这块空间,会出现野指针。

wKioL1b3owbibxRCAAATFI5Rwkc178.png

2)新版AutoPtr

我们及时将之前的指针置成空,将这块空间的所有权交给现在的指针。



#include<iostream>
using namespace std;

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* ptr)
    :_ptr(ptr)
    {}

    AutoPtr()
    :_ptr(NULL)
    {}

    AutoPtr<T>(AutoPtr<T>& ap)    //权限转移
        : _ptr(ap._ptr)
    {
        ap._ptr = NULL;
    }

    AutoPtr<T>& operator=(AutoPtr<T>& ap)
    {
        if (&ap != this)
        {
            delete _ptr;
            _ptr = ap._ptr;
            ap._ptr = NULL;     //权限转移
        }
        return *this;
    }

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

    T& operator*()
    {
        return *_ptr;
    }

private:
    T* _ptr;
};

void Test()
{
    AutoPtr<int> ap1(new int(2));
    AutoPtr<int> ap2 = ap1;
    AutoPtr<int> ap3(new int(3));
    ap3 = ap1;
}

int main()
{
    Test();
    system("pause");
    return 0;
}


二、ScopedPtr


这是最实用的智能指针。


顾名思义,守卫的指针,思想就是防拷贝,在大多时候用不到拷贝构造和赋值运算符重载,那么我们做的就是写出构造函数和析构函数,拷贝构造和赋值运算符重载只声明不定义。这里有几点要说明:


(1)鉴于上面,我们写智能指针时,将拷贝构造和赋值运算符重载设置成保护或者私有的,这样就可以保证其他人在不知情的情况下(以为是我们忘记写定义了)无法写拷贝构造和赋值运算符重载的定义。


(2)既然不要定义,那为什么要声明呢,是不是可以不要,或许你们会这样想。不可以!原因是你不写,编译器会自动调用系统自身的拷贝构造和赋值运算符重载,这样就没办法做到防拷贝了。


下面,我们用ScopedPtr来实现简易版本的智能指针。


#include<iostream>
using namespace std;

template<class T>
class ScopedPtr
{
public:
    ScopedPtr(T* ptr)
        :_ptr(ptr)
    {}

    Scoped()
        :_ptr(NULL)
    {}

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

    T& operator*()
    {
        return *_ptr;
    }

    T* GetPtr()
    {
        return _ptr;
    }

protected:
    ScopedPtr<T>(const ScopedPtr<T>& sp);
    ScopedPtr<T>& operator = (const ScopedPtr<T>& sp);

private:
    T* _ptr;
};

void Test()
{
    ScopedPtr<int> sp1(new int(2));
    ScopedPtr<int> sp2 = sp1;
    ScopedPtr<int> sp3(new int(3));
    sp3 = sp1;
}

int main()
{
    Test();
    system("pause");
    return 0;
}


三、SharedPtr


共享指针,即思想就是引用计数,引入变量指针变量pCount,指向一块空间,对其计数,当只有一个指针指向空间时再释放资源,实现对其管理。初衷也是解决多个指针指向同一块空间释放多次会崩溃。这里不用static的整型的pCount在于,若有多个指针指向第一块空间,多个指针指向第二块空间,……,当改变一块空间的指向,该块空间的引用计数发生变化了,static的pCount会导致其他空间的引用计数也发生变化。

#include<iostream>
using namespace std;

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

    SharedPtr()
        :_ptr(NULL)
        , _pCount(new long(1))
    {}

    SharedPtr<T>(const SharedPtr<T>& sp)
        : _ptr(sp._ptr)
        , _pCount(sp._pCount)
    {
        ++(*_pCount);
    }

    SharedPtr<T>& operator=(const SharedPtr<T>& sp)
    {
        if (&sp != this)
        {
            if (--(*_pCount) == 0)
            {
                delete _ptr;
                delete _pCount;
            }
            _ptr = sp._ptr;
            _pCount = sp._pCount;
            ++(*_pCount);
        }
        return *this;
    }

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

    T& operator*()
    {
        return *_ptr;
    }

    long GetCount()
    {
        return *(_pCount);
    }

    T* GetPtr()
    {
        return _ptr;
    }

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


void Test()
{
    SharedPtr<int> sp1 = new int(1);
    SharedPtr<int> sp2 = sp1;
    SharedPtr<int> sp3 = new int(2);
    sp3 = sp1;
}


int main()
{
    Test();
    system("pause");
    return 0;
}


四、ScopedArray

ScopedArray与ScopedPtr区别在于:

ScopedArray管理数组,不可实现访问单个元素,而ScopedArray数组,可实现对数组元素的操控。

#include<iostream>
using namespace std;
#include<assert.h>


template<class T>
class ScopedArray
{
public:
    ScopedArray(T* ptr = NULL)
        :_ptr(ptr)
    {}

    ~ScopedArray()
    {
        if (_ptr)
        {
            delete [] _ptr;
            _ptr = NULL;
        }
    }

    T& operator[](size_t index)
    {
        assert(index > 0);
        return _ptr[index];
    }
    
protected:
    ScopedArray<T>(const ScopedArray<T>& sp);
    ScopedArray<T>& operator=(const ScopedArray<T>& sp);

private:
    T* _ptr;
};

void Test()
{
    ScopedArray<int> sp1(new int[10]);
}

int main()
{
    Test();
}


五、SharedPtr

同四。

#include<iostream>
using namespace std;
#include<assert.h>

template<class T>
class SharedArray
{
public:
    SharedArray(T* ptr = NULL)
        :_ptr(ptr)
        , _pCount(new long(1))
    {}

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

    SharedArray<T> operator=(const SharedArray<T>& sp)
    {
        if (&s != this)
        {
            if (--(*pCount) == 0)
            {
                delete _ptr;
                _ptr = sp._ptr;
                (*pCount)++;
            }
        }
        return *this;
    }

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

    T* operator[](size_t index)
    {
        assert(index);
        return _ptr[index];
    }
private:
    T* _ptr;
    long *_pCount;
};


void Test()
{
    SharedArray<int> sp1(new int[10]);
    SharedArray<int> sp2(sp1);
    SharedArray<int> sp3 = sp1;
}

int main()
{
    Test();
    system("pause");
    return 0;
}


本文出自 “Han Jing's Blog” 博客,请务必保留此出处http://10740184.blog.51cto.com/10730184/1753183

从零开始学C++之boost库(一):详解 boost 库智能指针(scoped_ptr<T> 、shared_ptr<T> 、weak_ptr<T> 源码分析)

一、boost 智能指针 智能指针是利用RAII(Resource Acquisition Is Initialization:资源获取即初始化)来管理资源。关于RAII的讨论可以参考前面的文 章。在...
  • Simba888888
  • Simba888888
  • 2013年07月29日 17:15
  • 12270

我所熟悉的C++智能指针auto_ptr vs shared_ptr (一)

在开发过程中,曾经使用过两种C++的智能指针,如今,便总结一下,顺便比较比较二者使用中的区别,注意避免入坑的危险。:-D 我们知道,在C++中,如果创建一个指向某个对象的指针,那么在使用完这个对象...
  • u013700658
  • u013700658
  • 2015年10月28日 09:24
  • 1451

Boost 共享指针 共享数组

共享指针 shared_ptr已经作为技术报告1(TR1)的一部分被添加到标准。如果开发环境允许,可以使用memory中定义的std::shared_ptr。 在Boost C++库里,类...
  • PeterPan_hai
  • PeterPan_hai
  • 2016年06月21日 14:10
  • 1158

模拟实现auto_ptr、scoped_ptr、shared_ptr等智能指针

智能指针:所谓智能指针就是智能/自动化的管理指针所指向的动态资源的释放。 auto_ptr 有缺陷,自己赋值给自己,会失效置空 scoped_ptr 解决了auto_ptr缺陷,防拷贝 shar...
  • wanglelelihuanhuan
  • wanglelelihuanhuan
  • 2016年04月15日 13:59
  • 250

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

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

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

boost::scoped_ptr使用示例:#include #include #include using namespace std; class TestBody { public: ...
  • renyican
  • renyican
  • 2015年12月15日 14:42
  • 220

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

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

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

一句话总结: 1、auto_ptr 能够拷贝,能够转移所有权 2、scoped_ptr  不能拷贝,不能转移所有权 #include #include #include ...
  • Nick_666
  • Nick_666
  • 2017年08月03日 01:36
  • 127

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

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

学习笔记三:boost智能指针:scoped_ptr和shared_ptr

笔记,而非知识整理,仅供个人参考。当然如果能给其他同学帮助那就更好。...
  • tingyue_
  • tingyue_
  • 2015年06月28日 15:54
  • 530
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【C++】智能指针的作用,模拟实现auto_ptr,scoped_ptr,shared_ptr,scoped_array,shared_array
举报原因:
原因补充:

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