SmartPtr< T > Class Template Reference

Template class that provides automatic casting for hold RefCount based objects.

#include <SUIT_SmartPtr.h>


Public Member Functions

 SmartPtr ()
 default constructor
template<class Y>
 SmartPtr (Y *y_)
 constructor from any RefCount-based class
template<class Y>
 SmartPtr (const SmartPtr< Y > &y_)
 copy constructor from any RefCount-based class
 SmartPtr (const SmartPtr &t_)
 copy constructor
virtual ~SmartPtr (void)
 destructor
T & operator * () const
 return *pointer
T * operator-> () const
 return pointer
 operator T * () const
 return pointer
T * get () const
 return pointer
template<class Y>
SmartPtroperator= (const SmartPtr< Y > &y_)
 assignment
SmartPtroperator= (const SmartPtr &t_)
 assignment assignment
SmartPtroperator= (T *p_)
int operator== (const SmartPtr &t_)
 comparing
int operator== (const T *p_)
 comparing
int operator!= (SmartPtr &t_)
 comparing
int operator!= (T *p_)
 comparing
void nullify ()
 nullify
bool isNull () const
 check for null

Private Attributes

T * p
 stored pointer

Friends

int operator== (const T *p_, const SmartPtr &t_)
 comparing
int operator!= (T *p_, SmartPtr &t_)
 comparing

template<class T>
class SmartPtr< T >


Constructor & Destructor Documentation

template<class T>
SmartPtr< T >.SmartPtr  ) 
 

template<class T>
template<class Y>
SmartPtr< T >.SmartPtr Y *  y_  ) 
 

template<class T>
template<class Y>
SmartPtr< T >.SmartPtr const SmartPtr< Y > &  y_  ) 
 

template<class T>
SmartPtr< T >.SmartPtr const SmartPtr< T > &  t_  ) 
 

template<class T>
virtual SmartPtr< T >.~SmartPtr void   )  [virtual]
 


Member Function Documentation

template<class T>
T& SmartPtr< T >.operator *  )  const
 

template<class T>
T* SmartPtr< T >.operator->  )  const
 

template<class T>
SmartPtr< T >.operator T *  )  const
 

template<class T>
T* SmartPtr< T >.get  )  const
 

template<class T>
template<class Y>
SmartPtr& SmartPtr< T >.operator= const SmartPtr< Y > &  y_  ) 
 

template<class T>
SmartPtr& SmartPtr< T >.operator= const SmartPtr< T > &  t_  ) 
 

template<class T>
SmartPtr& SmartPtr< T >.operator= T *  p_  ) 
 

template<class T>
int SmartPtr< T >.operator== const SmartPtr< T > &  t_  ) 
 

template<class T>
int SmartPtr< T >.operator== const T *  p_  ) 
 

template<class T>
int SmartPtr< T >.operator!= SmartPtr< T > &  t_  ) 
 

template<class T>
int SmartPtr< T >.operator!= T *  p_  ) 
 

template<class T>
void SmartPtr< T >.nullify  ) 
 

template<class T>
bool SmartPtr< T >.isNull  )  const
 


Friends And Related Function Documentation

template<class T>
int operator== const T *  p_,
const SmartPtr< T > &  t_
[friend]
 

template<class T>
int operator!= T *  p_,
SmartPtr< T > &  t_
[friend]
 


Field Documentation

template<class T>
T* SmartPtr< T >.p [private]