智能指针

• RAII(Resource Acquisition Is Initialization)
  资源分配即初始化，定义一个类来封装资源的分配和释放，在构造函数完成资源 的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。
• 智能指针
  智能的自动化的管理指针所指向的动态资源的释放。既帮你管理指针，在用完后自动释放。
• 存在意义
  用于防止内存泄露的发生。在程序的编写过程中难免会发生内存泄露的情况，但这种错误又难以被人及时发现，所以使用智能指针实现空间的计时释放。
• 实例

#include <iostream>
using namespace std;
template<class T>
class AutoPtr
{
public:
    AutoPtr(T* ptr)
        :_ptr(ptr)
    {}
    ~AutoPtr()
    {
        if(_ptr)
        {
            delete _ptr;
        }
    }
    T& operator*()
    {
        return *_ptr;
    }
    T& operator->()
    {
        return _ptr;
    }
protected:
    T* _ptr;
};
void TestAutoPtr()
{
    AutoPtr<int> p1=new int(10); 
    AutoPtr<int> p2=p1;
}
int main()
{
    TestAutoPtr();
    system("pause");
    return 0;
}

此时程序会出现报错，原因是由于将一块空间释放了两次。
这里有3种解决方法：
1.管理权转移

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* ptr)
        :_ptr(ptr)
    {}
    ~AutoPtr()
    {
        if(_ptr)
        {
            delete _ptr;
        }
    }
    T& operator*()
    {
        return *_ptr;
    }
    T& operator->()
    {
        return _ptr;
    }
    //ap2(ap1)
    AutoPtr(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;
    }

protected:
    T* _ptr;
};
void TestAutoPtr()//测试用例
{
    AutoPtr<int> p1=new int(10); 
    AutoPtr<int> p2=p1;
    AutoPtr<int> p3=new int(5); 
    p2=p3;
}

分析：
管理权转移的方法虽然能暂时解决一部分问题，但它同时也带来许多问题。在程序的编写中并不能使用它来解决问题。

结论：
管理权转移只需理解原理，这实际是失败的设计，实际工作中不要使用！！！
2.防拷贝

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

protected:
    //声明成保护或私有,只声明不定义
    ScopedPtr(const ScopedPtr<T>& sp);
    ScopedPtr<T>& operator=(const ScopedPtr<T>& sp);

    T* _ptr;
};
void TestScopedPtr()//测试用例
{
    ScopedPtr<int> sp1(new int(20));
    ScopedPtr<int> sp2(sp1);
}

结论：
防拷贝是好的设计，但只适合于部分场景。使用时声明称保护或私有，只声明不定义。
3.引用计数

class SharedPtr
{
public:
    SharedPtr(T* ptr)
        :_ptr(ptr)
        ,_refCount(new int(1))
    {}
    ~SharedPtr()
    {
        if(--(*_refCount)==0)
        {
            delete _ptr;
            delete _refCount;
        }
    }
    T& operator*()
    {
        return *_ptr;
    }
    T& operator->()
    {
        return _ptr;
    }
    void Release()
    {
        if(--(*_refCount)==0)
        {
            delete _ptr;
            delete _refCount;
        }
    }
    //sp1(sp2)
    SharedPtr(SharedPtr<T>& sp)
        :_ptr(sp._ptr)
        ,_refCount(sp._refCount)
    {
        ++(*_refCount);
    }
    //sp1=sp2
    SharedPtr<T>& operator=(SharedPtr<T>& sp)
    {
        if(this!=&sp)
        {
            this->Relase();
            this->_ptr=sp._ptr;
            this->_refCount=sp._refCount;
            ++(*_refCount);
        }
        return *this;
    }
protected:
    T* _ptr;
    int* _refCount;
    //引用计数：管理同一块空间的对象数
};
   void TestSharedPtr()//测试用例
{
    SharedPtr<int> sp1(new int(20));
    SharedPtr<int> sp2(sp1);
}

分析：
工作原理：


结论：
<优点>功能强大，适用场景多
<缺点>循环引用，编写复杂