Re: template copy constructor
Now I have included some template operators
The definitions looks the following way
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() throw()
{
delete ptr;
}
odd_ptr<T> & operator=( odd_ptr<T> & rhs ) throw()
{
reset( rhs.release() );
return ( *this );
}
template <typename U>
odd_ptr<T> & operator=( odd_ptr<U> &rhs ) throw()
{
reset( rhs.release() );
return ( *this );
}
odd_ptr<T> & operator=( odd_ptr_ref<T> rhs ) throw()
{
reset( rhs.r.release() );
return ( *this );
}
template <typename U>
operator odd_ptr_ref<U>() throw()
{
return ( odd_ptr_ref<U>( *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;
};
And I have defined two class for testing
class X
{
public:
virtual ~X(){}
virtual std::ostream & out( std::ostream &os ) const
{
os << "Inside X object\n";
return ( os );
}
};
class Y: public X
{
public:
virtual ~Y(){}
virtual std::ostream & out( std::ostream &os ) const
{
os << "Inside Y object\n";
return ( os );
}
};
inline std::ostream & operator<<( std::ostream &os, const X &rhs )
{
return ( rhs.out( os ) );
}
template <typename T>
inline bool operator!( const odd_ptr<T> &rhs )
{
return ( !rhs.get() );
}
template <typename T>
inline odd_ptr<T> f()
{
return ( odd_ptr<T>( new T( 0 ) ) );
}
The following code is comliled well
odd_ptr<Y> py1( new Y );
std::cout << *py1 << std::endl;
odd_ptr<X> px1;
px1 = py1;
Here template <typename U> odd_ptr<T> & operator=( odd_ptr<U> & rhs )
throw() is called.
However the code
px1 = f<Y>();
is not compiled. I though that by analogy with assignment of objects of the
same types at first template <typename U> operator odd_ptr_ref<U>() will be
called and then idd_ptr<T> & operator=( odd_ptr_ref<T> &rhs ) will be called
too.
However I get an error. It seems that the compiler does not want to call the
conversion operator to convert odd_ptr<U> to odd_ptr_ref<T>. What is the
matter?
Vladimir Grigoriev