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

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;
}
更多相关文章
  •     RAII(Resource Acquisition Is Initialization)资源分配即初始化,定义一个类来封装资源的分配和释放,在构造函数完成资源的分配和初始化,在析构函数完成资源的清理,可以保证资源的正确初始化和释放.所谓智能指针就是智能/自动化的管理指针所指向的动态资源的释放 ...
  • c++智能指针的不断演化
    RAIIRAII资源分配即初始化,定义一个类来封装资源的分配和释放,在构造 函数完成资源的分配和初始化,在析构函数完成资源的清理,可以保证资源的正确初始化和释放. 智能指针的引入:由于return ,throw等关键字的存在,导致顺序执行流的错乱,不断的进行跳转,使开辟的空间看似被释放,而实际上导致 ...
  • 智能指针的实现
    看到了迭代器这里,想到了应该把智能指针的知识总结一下了 我实现了三种智能指针,分别是auto_ptr,scoped_ptr,shared_ptr命名是根据boost库中的智能指针命名的 什么是智能指针?智能指针可以帮助你在忘记释放new出来的内存的时候自动帮助你释放内存 可以有效避免内存泄漏 例如当 ...
  • 你的内存管理原则是否正确? 学c++的同学都知道这个内存管理原则,就是"谁创建,谁释放"或者说"谁申请,谁释放".简单地说,在代码上体现为,调用new或malloc等内存分配的人,同时需在内存使用完成后调用delete或free释放. 这个原则看似大家都同意, ...
  • 最近项目中使用boost库的智能指针,感觉智能指针还是蛮强大的,在此贴出自己学习过程中编写的测试代码,以供其他想了解boost智能指针的朋友参考,有讲得不正确之处欢迎指出讨论.当然,使用boost智能指针首先要编译boost库,具体方法可以网上查询,在此不再赘述.智能指针能够使C++的开发简单化,主 ...
  • 什么叫RAII(Resource Acquisition Is Initialization)?RAII指的就是资源分配即初始化,它的作用就是定义一个类来封装资源的分配和释放,在构造函数完成资源的分配和初始化,在析构函数完成资源的清理,可以保证资源的正确初始化和释放.它是一种技术.为什么要使用RAI ...
  •       Stl  中 auto_ptr只是众多可能的智能指针之一,auto_ptr所做的事情,就是动态分配对象以及当对象不再需要时自动执行清理.    这里是一个简单的代码示例,如果没有auto_ptr,        1void ProcessAdoption(istream &dat ...
  •     智能指针是C++实现自动内存管理的一种手段,本质是通过对象出作用域会自动析构,让对象保存与所需管理的目标指针指向同一片动态开辟空间的地址,出作用域会自动析构.这里模拟了,boost中的share智能指针,代码如下:#pragma once template<class T> cl ...
一周排行
  • 直接上代码:public static Bitmap scale(Bitmap bitmap, float scaleWidth, float scaleHeight) {  int width = bitmap.g ...
  • 冒泡排序算法可视化
    在百度前端技术学院的任务列表那里看到了有一个任务是要求用javascript实现可视化的排 ...
  • MySQL的MyISAM存储引擎修复及修改最大文件大小
     前两天生产库上出现了一个不大不小的故障,关于MySQL 的存储引擎问题.这个故障所涉及到 ...
  • struts2不要求我们自己设计的action类继承任何的struts基类或struts接口,但是我们为了方便实现我们自己的action,大多数情况下都会继承com.opensymphony.xwork2.Actio ...
  • 证书这个东西,我相信大家都知道,相信大家用过网上的支付宝,或者其他的,都应该知道.我们会给我们的系统安装系统的证书,那么这个证书代表什么呢?其实大家也可以查询一下,我们自己电脑上的证书,可以说证书这项技术还是比较安全 ...
  • 找工作感言    从今天开始离开了学校,算是毕业了,不想再回家,以前可以回去,自己一直认为家是自己避风的港湾,但现在不同了,再回去意味着自己的耻辱.    在学校学习计算机应用专业,由于没有学习好编程类知识,所以感觉 ...
  • 在微软桌面云解决方案技术中,提高远程桌面质量,富媒体的体验,多屏显示,设备重定向等功能都是必不可少的.这其中RemoteFX技术扮演了一个非常重要的作用,这个我们之前已经探讨过.但是如果终端设备是瘦终端并且采用嵌入式 ...
  • [[ ... ]]条件判断结构, 而不是[ ... ], 能够防止脚本中的许多逻辑错误. 比如,     &&, ||, <, 和> 操作符能够正常存在于[[ ]]条件判断结构中, 但是如 ...
  • windows计划任务无法正确执行
    windows服务器的计划任务同linux不太一样.执行起来需要用户名及密码的才能执行.否 ...
  • 转starling教程-触摸事件(TouchEvents)四
    在前面提到过,Starling是Sparrow的姊妹篇,正因为这样,Starling里的t ...