智能指针的实现

看到了迭代器这里，想到了应该把智能指针的知识总结一下了

我实现了三种智能指针，分别是auto_ptr,scoped_ptr,shared_ptr命名是根据boost库中的智能指针命名的

什么是智能指针？智能指针可以帮助你在忘记释放new出来的内存的时候自动帮助你释放内存

可以有效避免内存泄漏

例如当异常出现，跳转之后。。。内存是应该被释放的呀，一直抓住人家不放会造成内存泄漏哦

智能指针就是RAII（资源分配即初始化）一种典型的应用

 

利用类的构造函数和析构函数来进行内存的开辟和释放，智能指针不能完全说成是指针，它是一种类型用来管理指针的释放，当出了作用域之后，就回去进行内存释放

为了要让智能指针更像一个指针，需要对运算符进行重载：例如*引用

 

 

 

以上就是auto_ptr的部分代码，但是有个很明显的问题，那就是没有拷贝构造函数

当没有书写拷贝构造函数使用默认的拷贝构造函数的时候，这种语句就很危险了，涉及到深浅拷贝的问题，如何解决这种问题呢？

下面就讲！~

auto_ptr ——》自动释放指针（大坑货）：拷贝赋值之后，将前一个对象置空，这就完成了只释放一次（当出现拷贝的情况，两个指针分别释放其所指向的同一个空间就会boom！）

scoped_ptr——》守卫——》防拷贝：简单粗暴利用pravate不给你访问权限，不允许拷贝（既然拷贝会出错，那不拷贝不就没事了？）

shared_ptr——》共享——》引用计数：采用指针引用计数的方式进行，不采用普通类型，也不用静态变量，就是要用指针（其实最推荐使用的居然是仿拷贝指针，就是说，没必要拷贝就别拷贝了，必须拷贝再用共享指针）

贴出代码！

class AutoPtr
{
public:
    explicit AutoPtr(T* ptr=NULL)
        :_ptr(ptr)
    {
    }
    AutoPtr(AutoPtr& ap)
        :_ptr(ap._ptr)
    {
        ap._ptr = NULL;
    }
    ~AutoPtr()
    {
        delete _ptr;
    }
    AutoPtr& operator=(AutoPtr& ap)
    {
        if (_ptr != ap._ptr)
        {
            if (NULL == _ptr)
            {
                _ptr = ap._ptr;
                ap._ptr = NULL;
            }
            else
            {
                delete _ptr;
                _ptr = ap._ptr;
                ap._ptr = NULL;
            }
        }
        return *this;
    }
    T& operator *()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
    T* GetPtr()
    {
        return _ptr;      
    }
private:
    T* _ptr;
};



void test1()
{
    AutoPtr<int > ap1 = new int;//支持强转（这里的意思是，new产生的int *会被强转成auto_ptr指针，就是说会拿int *构造临时的auto_ptr变量然后再赋值）
    AutoPtr<int > ap2 = new int;
    //AutoPtr<int >ap3(ap1);//当心，深浅拷贝
    AutoPtr<int > ap4;
    ap4 = ap1;
    ap2 = ap1;
    /*int *p1 = new int;
    int *p2 = new int;
    delete p1;
    delete p2;*/
}

PS：最长注释的那句AutoPtr<int > ap1 = new int;如果不希望这种事情发生的话要用到explicit关键字

我把测试用例也贴出来了~auto_ptr的实现还是非常简单的，但是就是太坑了，最好不要使用~

接下来是防拷贝智能指针scoped_ptr

#include<iostream>
using namespace std;



template<class T>
class ScopedPtr
{
public:
    explicit ScopedPtr(T* ptr=NULL)
        :_ptr(ptr)
    {
    }
    ~ScopedPtr()
    {
        if (_ptr)
        {
            delete _ptr;
        }
    }
    T* operator ->()
    {
        return _ptr;
    }
    T& operator *()
    {
        return *_ptr;
    }
    T* GetPtr()
    {
        return _ptr;
    }

private:
    ScopedPtr(ScopedPtr& sp)
    {

    }
    ScopedPtr& operator=()
    {

    }
private:
    T* _ptr;
};



void test1()
{

    ScopedPtr<int> sp1 = new int(1);
    ScopedPtr<int> sp2 = new int(2);
    ScopedPtr<int> sp3(sp1);
}

执行这个代码的话就会报编译错误啦，因为拷贝构造放在私有成员里了，是不能使用哒，实现也非常简单，就把关于拷贝的东西全都丢给private就对了

 接下来是共享指针shared_ptr

#include<iostream>
using namespace std;
template<class T>
class SharedPtr
{
public:
    explicit SharedPtr(T* ptr)
        :_ptr(ptr)
        ,_pCount(new int(1))
    {

    }
    SharedPtr(SharedPtr& sp)
        :_ptr(sp._ptr)
        ,_pCount(sp._pCount)
    {
        (*_pCount)++;
    }
    ~SharedPtr()
    {
        if (--(*_pCount) == 0)
        {
            delete _ptr;
            delete _pCount;
        }
    }
    SharedPtr& operator=(SharedPtr& sp)
    {
        if (_ptr != sp._ptr)
        {
            if (NULL == _ptr)
            {
                _ptr = sp._ptr;
                _pCount = sp._pCount;
            }
            else
            {
                _Release();
            }
        }
        return *this;
    }
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
protected:
    void _AddRef()
    {
        ++(*_pCount);
    }
    void _Release()
    {
        if (--(*_pCount) == 0)
        {
            delete _ptr;
            delete _pCount;
            _ptr = NULL;
            _pCount = NULL;
        }
    }
private:
    T* _ptr;
    int* _pCount;
};

引用计数是用指针来实现的，一开始采用的是静态变量，但是有个问题，当声明

SharedPtr<int> s = new int(20);
SharedPtr<int> s1=new int (30);

因为存储的数值不同，引用计数应该是不会增长的，但是由于采用了静态变量，该类对象都使用了这个引用计数，就会都往引用计数上加，这就错了

采用指针，开辟出独有的一块空间来管理计数显然才是我们所需要的，析构的时候把delete掉的指针赋空会更好~所以有了Release函数

应该在构造函数之前加上explicit关键字，是为了防止将指针经过转换构造函数变成智能指针，就是防止

int *ptr;

autoptr<int> a;

a=ptr;

这样的转换发生