智能指针

RAII是一种规范，用来解决问题的思想，定义类来封装资源分配和释放，构造函数完成资源的分配和初始化，析构函数完成资源的清理
智能指针不是指针，是一个类，可以实现
1. 智能管理指针的释放
2. 能够像指针一样使用
3. 完成正常的赋值拷贝
是RAII的一种应用
auto_ptr：较早期的智能指针，在实现赋值运算符重载时，使用管理权的转移来实现，有缺陷；

templete<classＴ>
class AutoPtr
｛
public:
    AutoPtr(T*ptr=NULL)
    :_ptr(ptr)
    {}
    T& operator*()
    {
        return *_ptr;
    }
    T&operator->()
    {
        return _ptr;
    }
    AutoPtr<T>operator=(AutoPtr<T>&ap)
    {
        if(this!=&ap)//管理权转移
        {
            delete this->_ptr;
            _ptr=ap._ptr;
            ap._ptr=NULL;
        }
    }
    AutoPtr(AutoPtr<T>&ap)
        :_ptr(ap._ptr)
        {
            ap._ptr=NULL;
        }
protected:
    T*_ptr;
｝

如果不完成管理权的转移，两个指针指向同一块地址，析构的时候调用两次析构函数，第二次调用析构函数的时候程序会找不到指针，但是如果只用管理权的转移来实现赋值运算符重载和拷贝构造函数，和本身的智能指针的用途不符，是一个有缺陷的智能指针。
scoped_ptr是因为AutoPtr有缺陷从而发展出来的版本，防止调用拷贝构造函数和赋值运算符重载，对拷贝构造函数和赋值运算符重载只声明，不定义

templete<classＴ>
class ScopedPtr
｛
public:
    ScopedPtr(T*ptr)
    :_ptr(ptr)
    {}
    T& operator*()
    {
        return *_ptr;
    }
    T&operator->()
    {
        return _ptr;
    }
protected:
    T*_ptr;
    ScopedPtr(const ScopedPtr& sp);
    ScopedPtr<T>&operator=(const ScopedPtr<T>&);
｝

shared_ptr利用引用计数完成赋值运算符重载和拷贝构造函数，缺陷是循环引用

templete<classＴ>
class SharedPtr
｛
public:
    SharedPtr(T*ptr=NULL)
    :_ptr(ptr)
    ,_CountRef(new int(1))
    {}
    T& operator*()
    {
        return *_ptr;
    }
    T&operator->()
    {
        return _ptr;
    }
    inline void Release()
    {
        if(--(*_CountRef)==0)
        {
            delete _ptr;
            delete _CountRef;
        }
    }
    SharedPtr<T>&operator=(const SharedPtr<T>&sp)
    {
        if(_ptr!=sp/ptr)
        {
            this->release();
            _ptr=sp.ptr;
            _CountRef=sp.CountRef;
            ++(*_CountRef);
        }
        return *this;
    }
    SharedPtr(T*ptr)
        :_ptr(sp._ptr)
        {
            ++(*_CountRef);
        }
        ~SharedPtr()
        {
            Release();
        }
protected:
    T*_ptr;
    size_t * _countRef;//引用计数

｝

但是sharedptr在面对这样的代码时会有缺陷

cur->next=next;
next->prev=cur;

next和cur的引用计数都会变成1，而不是析构。
面对这样的问题诞生了一个智能指针weakptr（）来配合sharedptr，在面对这样的循环引用的时候。在sharedptr内，将成员定义成weak_ptr,这个智能指针的作用是当部分发生引用时，是不会改变引用计数的值的，从而解决循环引用
shared_ptr还不能处理string类型的数据，需要定制删除器

class Deletearrary()
{
    public:
        void operator()(T*_ptr)
        {
        delete[] _ptr;
        }
}