自动指针实现

通过栈对象来管理堆空间。如果我在堆内存中申请了资源，由于系统不会主动清理堆空间，因此可能存在忘了写释放语句从而内存泄露的问题。使用自动指针可以一定程度上避免该问题。

自动指针是转移拷贝语义，即对象间赋值之后源对象不存在了...所以为避免编译器的浅拷贝行为，需要重载赋值运算符。

下面是自动指针的简单实现：

class autoptr{
private:
    T* p_t;   //此处p_t指向堆对象，当autoptr<T>离开作用域时，触发析构函数，析构函数中执行delete，于是堆对象就能自动释放了
    T* release(){
        T* p = p_t;
        p_t = NULL;
        return p;
    }
    void reset(T* p){
        if(p!=p_t){
            delete p_t;
            p_t = p;
        }    
    }
public:
    autoptr(T* p=NULL):p_t(p){}
    ~autoptr(){
        if(p_t)  delete p_t;
    }
    //拷贝构造
    autoptr(autoptr<T>& that):p_t(that-release()){}
    //重载运算符
    //拷贝构造与赋值运算的差异(我觉得内存的处理差不多，赋值运算内存空间是之前就存在的，而拷贝构造需要新创建内存空间)
    autoptr& operator=(autoptr<T>& that){  
        if(this!=&that)
            reset(that.release());
        return *this;
    }
    T& operator*(void)const{
        return *p_t;
    }
    T* operator->(void)const{
        return &**this;
    }
};

但是如果p_t指向数组，那么显然autoptr就不起作用了，因为数组的释放需要的是delete[]。

所以需要针对数组做简单的特化，那么首先想到，针对成员函数做特化，因为存在差异的就只有delete出现的语句。

但是注意到 T[] 这个数组有几个类型参数呢？明显有类型 T 和 [] (数组)，现在我确定了类型 [] , 但类型 T 只有在实例化时才能确定，因此我需要做的是局部特化，即只特化部分类型参数。

因为函数模板不能做局部特化，所以在此只能选择类模板的局部特化。（函数可以重载，所以不能做局部特化）

下面是针对数组类型的特化：

//代码微调即可
template<typename T>
class autoptr<T[]>{
private:
    T* p_t;   
    T* release(){
        T* p = p_t;
        p_t = NULL;
        return p;
    }
    void reset(T* p){
        if(p!=p_t){
            delete[] p_t;
            p_t = p;
        }    
    }
public:
    autoptr(T* p=NULL):p_t(p){}
    ~autoptr(){
        if(p_t)  delete[] p_t;
    }
    autoptr(autoptr<T>& that):p_t(that-release()){}
    autoptr& operator=(autoptr<T>& that){  
        if(this!=&that)
            reset(that.release());
        return *this;
    }
    T& operator*(void)const{
        return *p_t;
    }
    T* operator->(void)const{
        return &**this;
    }
};

 

转载于:https://www.cnblogs.com/young8848/p/4382124.html