scoped_ptr防拷贝

进行资源管理有二种方法，第一种是auto_ptr,资源转移auto_ptr,
auto_ptr智能指针中，存在无法解决的问题，所以我们在管理资源时，最好不要用auto_ptr来进行资源的转移管理资源，第二种是scoped_ptr，所谓的防拷贝就是不用拷贝构造函数和赋值运算符重载函数；但在类中又不能不写，因为系统会自动合成

auto_ptr智能指针

template<class T>
class autoptrref
{
public:
    autoptrref(T* ptr = NULL)
        :_ptr(ptr)
    {}
    T* _ptr;
};

template<class T>
class autoptr
{
public:
    //构造函数
    autoptr(T* ptr = NULL)
        :_ptr(ptr)
    {}

    //拷贝构造函数
    autoptr(autoptr<T>& ap)
        :_ptr(ap._ptr)
    {
        ap._ptr = NULL;//拷贝完后将ap._ptr置NULL
    }

    //赋值运算符的重载
    autoptr<int>& operator=(autoptr<T>& ap)
    {
        if(this!=&ap)
        {
            if(_ptr!=NULL)
            {
                delete _ptr;
            }
            _ptr = ap._ptr;
            ap._ptr = NULL;//赋值完后将ap._ptr置NULL
        }
        return *this;
    }

    //解决办法

    //重载autoptrref()
    operator autoptrref<T>()//将autoptr<T>转化为autoptrref<T>
    {
        autoptrref<T> temp(_ptr);
        _ptr = NULL;
        return temp;
    }

    //再重载一个拷贝构造函数
    autoptr(const autoptrref<T>& apr)
        :_ptr(apr._ptr)
    {}

    ~autoptr()//析构函数
    {
        if(_ptr!=NULL)
        {
            delete _ptr;
        }
    }

    //->的重载
    T* operator->()const
    {
        return _ptr;
    }

    //*的重载
    T& operator*()const
    {
        return *_ptr;
    }

    //得到原生态指针
    T* Get()const
    {
        return _ptr;
    }

private:
    T* _ptr;
};
void funtest()
{
    autoptr<int> ap(autoptrref<int>(autoptr<int> (new int)));//用无名的智能指针拷贝构造智能指针ap,则不会调用我们编写好得拷贝构造函数，而是调用系统自动合成个的拷贝构造函数
}    //原因是编译器的自动优化，解决办法：重新增加一个类autoptrref,将无名对象的类型转化为autoptrref                                       

int main()
{
    funtest();
    getchar();
    return 0;
}

socped_ptr的实现

template<class T>
calss scoped_ptr
{
public:
    scopedptr(T* ptr)
        :_ptr(ptr)
    {}

    ~scopedptr()
    {
        if(_ptr!=NULL)
        {
            delete _ptr;
            _ptr = NULL;
        }
    }


    //方法一：将拷贝构造函数和赋值运算符重载函数给成私有成员函数，给出函数定义，函数体可以为NULL，因为没有任何意义
private:
    //给出定义
    scopedptr(const scopedptr<int>& sp)
    {}
    scopedptr<T> operator=(const scopedptr<T>& ap)//缺点：不清楚如何给出实体
    {}

    //方法二：将拷贝构造函数和赋值运算符重载函数给成公共的类成员函数，但不给出定义
    scopedptr(const scopedptr<int>& sp);
    scopedptr<T> operator=(const scopedptr<T>& ap);//缺点：这种情况可能会有用户在类的外面自己定义

    //方法三：将拷贝构造函数和赋值运算符重载函数给成私有的成员函数，但只声明不定义
private:
    scopedptr(const scopedptr<int>& sp);
    scopedptr<T> operator=(const scopedptr<T>& ap);//防拷贝的最好的选择

    //方法四：不给出拷贝构造函数和赋值运算符重载函数

    //缺点：编译器会自动合成

private:
    T* _ptr;
};

void funtest()
{
    scopedptr<int> sp1(int new);
    scopedptr<int> sp2(int new);

}
int mian()
{
    return 0;
}