1.vc
template<class _Ty>
class auto_ptr
{
public:
typedef _Ty element_type;
auto_ptr(_Ty *_P = 0) : _Owns(_P != 0), _Ptr(_P)
{}
//拷贝构造 将_Y的管理权_Owns = false 释放后将指针赋值过去
auto_ptr(const auto_ptr<_Ty>& _Y) : _Owns(_Y._Owns), _Ptr(_Y.release())
{}
auto_ptr<_Ty>& operator=(const auto_ptr<_Ty>& _Y) _THROW0()
{
if(this != &_Y)//防止字赋值
{
if (_Ptr != _Y.get())
{
if (_Owns)
delete _Ptr;//当Owns为真的时候，释放其ptr所指的空间
_Owns = _Y._Owns;
}
else if (_Y._Owns)
_Owns = true;
_Ptr = _Y.release();//
}
return (*this);
}
~auto_ptr()
{
//程序结束时析构函数被调用，释放空间
if (_Owns)
delete _Ptr;
}
//重载*后，具有和指针相似的访问形式
_Ty& operator*() const _THROW0()
{
return (*get());
}
_Ty *operator->() const _THROW0()
{
return (get());
}
_Ty *get() const _THROW0()
{
return (_Ptr);
}
_Ty *release() const _THROW0()//只是将Owns置为false，没有改变指针指向
{
((auto_ptr<_Ty> *)this)->_Owns = false;
return (_Ptr);
}
private:
bool _Owns;
_Ty *_Ptr;
};
int main（）
{
int *p = (int *)malloc(sizeof(int));
*p = 3;
int *q = (int *)malloc(sizeof(int));
*q = 5;
auto_ptr<int> pa(p);
auto_ptr<int> pb(q);
pa = pb;
cout<<*pa<<endl;//此时输出都是5
cout<<*pb<<endl;//输出5
return 0;
}
如上图
2.linux
template<class _Ty>
class auto_ptr
{
public:
explicit auto_ptr(_Ty *p = 0):_M_Ptr(p)
{
}
~auto_ptr()
{
delete _M_Ptr;
}
auto_ptr(auto_ptr<_Ty> &_Y):_M_Ptr(_Y.release())
{
}
_Ty& operator *()
{
return *_M_Ptr;
}
_Ty& operator ->()
{
return (*this)->_M_Ptr;
}
auto_ptr<_Ty> &operator =(auto_ptr<_Ty> & _Y)//不同之处
{
reset(_Y.release());
return *this;
}
_Ty* release()
{
_Ty *_tmp = _M_Ptr;
_M_Ptr = 0;//linux下将指针置为空，此时若访问转移权限
return _tmp;
}
void reset(_Ty *_ptr = 0)//重置对指针的管理
{
_Ty * _pt = _M_Ptr;
if(_ptr!=_pt)
{
delete _pt;//先delete掉前指针的空间，避免造成内存泄漏
}
_M_Ptr = _ptr;
}
private:
_Ty* _M_Ptr;//与vc下不同的是没有权限标志
};
pb连访问的机会也失去了。。。。。
如有错误，欢迎前辈们指点，嘿嘿。
原文地址：http://10979088.blog.51cto.com/10969088/1850852
