Re: auto_ptr definition
Nagrik wrote:
Hello group,
I came across this definition of auto_ptr at Wikipedia.
The auto_ptr class is declared in ISO/IEC 14882, section 20.4.5 as:
namespace std {
template <class Y> struct auto_ptr_ref {};
template<class X>
class auto_ptr {
public:
typedef X element_type;
// 20.4.5.1 construct/copy/destroy:
explicit auto_ptr(X* p =0) throw();
auto_ptr(auto_ptr&) throw();
template<class Y> auto_ptr(auto_ptr<Y>&) throw();
auto_ptr& operator=(auto_ptr&) throw();
template<class Y> auto_ptr& operator=(auto_ptr<Y>&)
throw();
auto_ptr& operator=(auto_ptr_ref<X> r)
throw();
~auto_ptr() throw();
// 20.4.5.2 members:
X& operator*() const throw();
X* operator->() const throw();
X* get() const throw();
X* release() throw();
void reset(X* p =0) throw();
// 20.4.5.3 conversions:
auto_ptr(auto_ptr_ref<X>) throw();
template<class Y> operator auto_ptr_ref<Y>() throw();
template<class Y> operator auto_ptr<Y>() throw();
};
}
I am confused about the syntex of third constructor in this
definition
/*****
template<class Y> auto_ptr(auto_ptr<Y>&) throw();
*/
This template constructor is used for conversion between different
pointers, when conversion exists.
see:
auto_ptr<Derived> spD(new Derived);
auto_ptr<Base> spB(spD);
It looks like a constructor, which takes a parameter type
auto_ptr<Y>&, which in turn is another template class (empty struct)
*empty* here means implementation defined, I think.
named auto_ptr_ref and returns
template<class Y>
Can someone explain the whole syntex of this constructor. I
know the constructor are not supposed to return any value, then
why does this one return
template<class Y>
the conversion between auto_ptr_ref and auto_ptr is done transparent to
the user.
see:
void f(auto_ptr<int> sp) {}
int main() {
f(auto_ptr<int>(new int(10))); // temporary variable
}
temporary variable is rvalue, while auto_ptr copy ctor requires lvalue
(a reference, NOT const reference),
/operator auto_ptr_ref<X>()/ is called for conversion(meanwhile give up
ownership by calling release) to auto_ptr_ref, then constructor
auto_ptr(auto_ptr_ref<X>) is called.
the same thing happens when you write code like this:
auto_ptr<int> f() { return auto_ptr<int>(new int(10)); }
well, read some implementation, and have a debugger to see what's going on,
aside, VC8 has something wrong with auto_ptr_ref implementation, and use
/Za to disable extension, cause the extension even has something wrong
with the semantic of *explicit*
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]