Re: template copy constructor
Well, I have started from the very beginning. I have written the auto_ptr
without template functions, and it works.
template <typename T>
class odd_ptr
{
private:
template <typename U>
struct odd_ptr_ref
{
odd_ptr_ref( odd_ptr<U> &rhs ): r( rhs ){}
odd_ptr<U> &r;
};
public:
typedef T element_type;
explicit odd_ptr( T *p = 0 ) throw(): ptr( p ){}
odd_ptr( odd_ptr<T> &rhs ) throw(): ptr( rhs.release() ){}
odd_ptr( odd_ptr_ref<T> rhs ) throw(): ptr( rhs.r.release() ){}
~odd_ptr() { delete ptr; }
odd_ptr & operator=( odd_ptr<T> & rhs ) throw()
{
reset( rhs.release() );
return ( *this );
}
odd_ptr & operator=( odd_ptr_ref<T> rhs ) throw()
{
reset( rhs.r.release() );
return ( *this );
}
operator odd_ptr_ref<T>() throw()
{
return ( odd_ptr_ref<T>( *this ) );
}
T & operator*() const throw()
{
return ( *ptr );
}
T * operator->() const throw()
{
return ( return ( ptr ) );
}
T * get() const throw()
{
return ( ptr );
}
T * release() throw()
{
T *p = ptr;
ptr = 0;
return ( p );
}
void reset( T *p = 0 )
{
if ( ptr != p )
{
delete ptr;
ptr = p;
}
}
private:
T *ptr;
};
For constructions as the following
odd_ptr<int> pi1( new int( 10 ) );
odd_ptr<int>pi2( pi1 );
the copy constructor is called.
For constructions as the following
odd_ptr<int> pi1( new int( 10 ) );
odd_ptr<int>pi2 = pi1;
also the copy constructor is called, i.e. the compiler skips the step of
generating odd_ptr<int>( pi1 ).
For constructions as the following
template <typename T>
odd_ptr<T> f()
{
return ( odd_ptr<T>( new T( 0 ) ) );
}
odd_ptr<int> pi1 = f<int>();
at first operator odd_ptr_ref<T>() throw() is called and then odd_ptr(
odd_ptr_ref<T> rhs ) throw(): ptr( rhs.r.release() ){} is called.
However looking through some articles about auto_ptr I do not find sometimes
such operator as
odd_ptr & operator=( odd_ptr_ref<T> rhs ) throw()
{
reset( rhs.r.release() );
return ( *this );
}
which is needed in my code for executing
odd_ptr<int> pi1;
pi1 = f<int>();
Is set of constructors and operators for auto_ptr predefined in C++
standard? Does the above assignment operator exist in the standard set of
functions for auto_ptr or other conversion sequence is used for the
statement pi1 = f<int>()?
Vladimir Grigoriev