auto_ptr中的auto_ptr_ref
2013-01-08 18:00
295 查看
先看看类auto_ptr的内部实现机制:
template<typename _Tp>
class auto_ptr
{
private:
_Tp* _M_ptr;
public:
typedef _Tp element_type;
//////****构造函数******/
explicit
auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
template<typename _Tp1>
auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
/*******重载赋值操作***********/
auto_ptr&
operator=(auto_ptr& __a) throw()
{
reset(__a.release());
return *this;
}
template<typename _Tp1>
auto_ptr&
operator=(auto_ptr<_Tp1>& __a) throw()
{
reset(__a.release());
return *this;
}
//********析构****/
~auto_ptr() { delete _M_ptr; }
/*******成员函数****************/
element_type*
get() const throw() { return _M_ptr; }
element_type*
release() throw()
{
element_type* __tmp = _M_ptr;
_M_ptr = 0;
return __tmp;
}
void reset(element_type* __p = 0) throw()
{
if (__p != _M_ptr)
{
delete _M_ptr;
_M_ptr = __p;
}
}
/*********以下就是auto_ptr不同于其他智能指针的地方*********/
template<typename _Tp1>
struct auto_ptr_ref
{
_Tp1* _M_ptr;
explicit
auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
};
auto_ptr(auto_ptr_ref<element_type> __ref) throw()
: _M_ptr(__ref._M_ptr) { }
auto_ptr&
operator=(auto_ptr_ref<element_type> __ref) throw()
{
if (__ref._M_ptr != this->get())
{
delete _M_ptr;
_M_ptr = __ref._M_ptr;
}
return *this;
}
template<typename _Tp1>
operator auto_ptr_ref<_Tp1>() throw()
{ return auto_ptr_ref<_Tp1>(this->release()); }
template<typename _Tp1>
operator auto_ptr<_Tp1>() throw()
{ return auto_ptr<_Tp1>(this->release()); }
};
}
之所以有auto_ptr_def,主要是因为auto_ptr的特性,auto_ptr注重对所指对象的拥有权,不能够有两个或两个以上的auto_ptr类型的指针同时指向一个对象,这就使得其拷贝构造函数的形参是引用类型,而非常引用。于是就出现了这样的问题:
auto_ptr<int> ptr2( auto_ptr<int>( new int(1) ) );语句不能够通过编译,因为
auto_ptr<int>( new int(1) )是个right-Value,对右值进行引用是非法的;也许会有人想为什么不把拷贝构造函数实现能这样:
auto_ptr(auto_ptr __a) throw() : _M_ptr(__a.release()) { }-----------(1)
这样就会和
auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }---------(2)
重载错误问题,但是如果只保留(1),那auto_ptr强调对资源拥有权的特性就会消失了,还好Bill Gibbons和Greg ColvinBill Gibbons和Greg Colvin利用模板和重载的差别引入了auto_ptr_ref,
auto_ptr(auto_ptr_ref<element_type> __ref) throw()
: _M_ptr(__ref._M_ptr) { }-------------------------(3)
是可以和(2)重载共存的,当然auto_ptr ptr(auto_ptr<int>(new int(1)));可以通过编译了(调用(3)拷贝构造函数)。
同理:auto_ptr ptr = auto_ptr<int>(new int(1))能通过编译也是借助于auto_ptr_ref的功能。
本文出自 “东方快翔” 博客,请务必保留此出处http://hustluy.blog.51cto.com/1792080/502132
template<typename _Tp>
class auto_ptr
{
private:
_Tp* _M_ptr;
public:
typedef _Tp element_type;
//////****构造函数******/
explicit
auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
template<typename _Tp1>
auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
/*******重载赋值操作***********/
auto_ptr&
operator=(auto_ptr& __a) throw()
{
reset(__a.release());
return *this;
}
template<typename _Tp1>
auto_ptr&
operator=(auto_ptr<_Tp1>& __a) throw()
{
reset(__a.release());
return *this;
}
//********析构****/
~auto_ptr() { delete _M_ptr; }
/*******成员函数****************/
element_type*
get() const throw() { return _M_ptr; }
element_type*
release() throw()
{
element_type* __tmp = _M_ptr;
_M_ptr = 0;
return __tmp;
}
void reset(element_type* __p = 0) throw()
{
if (__p != _M_ptr)
{
delete _M_ptr;
_M_ptr = __p;
}
}
/*********以下就是auto_ptr不同于其他智能指针的地方*********/
template<typename _Tp1>
struct auto_ptr_ref
{
_Tp1* _M_ptr;
explicit
auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
};
auto_ptr(auto_ptr_ref<element_type> __ref) throw()
: _M_ptr(__ref._M_ptr) { }
auto_ptr&
operator=(auto_ptr_ref<element_type> __ref) throw()
{
if (__ref._M_ptr != this->get())
{
delete _M_ptr;
_M_ptr = __ref._M_ptr;
}
return *this;
}
template<typename _Tp1>
operator auto_ptr_ref<_Tp1>() throw()
{ return auto_ptr_ref<_Tp1>(this->release()); }
template<typename _Tp1>
operator auto_ptr<_Tp1>() throw()
{ return auto_ptr<_Tp1>(this->release()); }
};
}
之所以有auto_ptr_def,主要是因为auto_ptr的特性,auto_ptr注重对所指对象的拥有权,不能够有两个或两个以上的auto_ptr类型的指针同时指向一个对象,这就使得其拷贝构造函数的形参是引用类型,而非常引用。于是就出现了这样的问题:
auto_ptr<int> ptr2( auto_ptr<int>( new int(1) ) );语句不能够通过编译,因为
auto_ptr<int>( new int(1) )是个right-Value,对右值进行引用是非法的;也许会有人想为什么不把拷贝构造函数实现能这样:
auto_ptr(auto_ptr __a) throw() : _M_ptr(__a.release()) { }-----------(1)
这样就会和
auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }---------(2)
重载错误问题,但是如果只保留(1),那auto_ptr强调对资源拥有权的特性就会消失了,还好Bill Gibbons和Greg ColvinBill Gibbons和Greg Colvin利用模板和重载的差别引入了auto_ptr_ref,
auto_ptr(auto_ptr_ref<element_type> __ref) throw()
: _M_ptr(__ref._M_ptr) { }-------------------------(3)
是可以和(2)重载共存的,当然auto_ptr ptr(auto_ptr<int>(new int(1)));可以通过编译了(调用(3)拷贝构造函数)。
同理:auto_ptr ptr = auto_ptr<int>(new int(1))能通过编译也是借助于auto_ptr_ref的功能。
本文出自 “东方快翔” 博客,请务必保留此出处http://hustluy.blog.51cto.com/1792080/502132
相关文章推荐
- auto_ptr_ref的奇妙(下)
- 关于auto_ptr_ref的一点问题
- auto_ptr、auto_ptr_ref及它们存在的问题
- 浅析为什么要有auto_ptr_ref这个类
- auto_ptr &auto_ptr_ref
- auto_ptr与auto_ptr_ref
- auto_ptr_ref 原理解析
- 关于auto_ptr_ref的一点问题
- 为什么需要auto_ptr_ref
- 为什么需要auto_ptr_ref
- auto_ptr_ref
- 为什么需要 auto_ptr_ref
- auto_ptr_ref和auto_ptr的关系 .
- 为什么需要auto_ptr_ref
- 为什么需要auto_ptr_ref
- 为什么需要auto_ptr_ref
- 为什么需要auto_ptr_ref
- 一个auto_ptr_ref引发的连锁思考
- 通用工具Utilities(一):STL中auto_ptr的实现以及auto_ptr_ref的理解
- auto_ptr_ref的奇妙