---

SmartPointer< T > Class Template Reference
[ReferenceCounting]

#include <SmartPointer.h>

List of all members.

Public Methods
	SmartPointer ()
	~SmartPointer ()
	operator T * ()
T *	ptr () const
	SmartPointer (T *t)
	SmartPointer (const SmartPointer< T > &sp)
T &	operator * ()
SmartPointer< T > &	operator= (const SmartPointer< T > &sp)
T *	operator-> ()
Static Public Methods
void	bind (SmartPointer< T > &sp, T **obj)
void	referTo (SmartPointer< T > &sp, T *obj)
Protected Attributes
T *	obj

---

Detailed Description

template<class T>
class SmartPointer< T >

A class whose instances act like pointers that manage their reference count automatically.

Use smart pointers when you wish to keep a reference to a instance of a subclass of IotrRefCount. Do not use a smart pointer to refer to an object passed in as a parameter to a routine, unless you intend to keep the reference after the routine has exited.

Instances of this class are created by value. In other words definitions such as

 SmartPointer<T> t; 

are encouraged, whereas pointers to objects of type SmartPointer<T> should not be used.

Method calls through a smart pointer look like calls to a regular pointer. In other words

 class T {
    public:
       void myMethod();
 };
 // ...
 {    
   SmartPointer<T> t;
    // ...
     t->myMethod();
 }

is the preferred way to call T::myMethod through a smart pointer.

SmartPointers can be assigned a pointer to an object through the function SpReferTo(). It is never necessary to release a a SmartPointer, this will be done automatically whenever the SmartPointer goes out of scope. It is not possible, or necessary, to call IotrRelease() or IotrAddRef() on a SmartPointer.

Assignments between SmartPointers should work with the same semantics as assigment of traditional pointers.

 SmartPointer<T> t, s;
 //...
 t = s;

or

 SmartPointer<T> sp(new T);

or

 T * t = new T;
 SmartPointer<T> sp;
 sp = SmartPointer<T>(t); // or sp = (SmartPointer<T>) t;

So long as implicit conversion

 sp = t;

is disallowed. SmartPointers should generally not be in the definition of parameters to routines or as return values. Use traditional pointers for these. Automatic conversion allows SmartPointers to be a "drop-in" replacement to traditional pointers when calling routines.

 class T { // ... 
 };
 // ...
 void myRoutine( T * t );
 
 //...
 { 
     SmartPointer<T> t;
     // ...
     myRoutine t );
 }

When returning pointers from a function, be sure to use SpAsPointer() to obtain the traditional pointer to the object.

 class T { // ... 
 };
 // ...
 T * myFunction( T * t );
 {
     SmartPointer<T> t;
     // ...
     return SpAsPointer( t );
 }

See also:

IotrRefCount , ReferenceCounting

---

Constructor & Destructor Documentation

template<class T> SmartPointer< T >::SmartPointer (    )  [inline]

Default constructor; creates a SmartPointer referring to nothing.

template<class T> SmartPointer< T >::SmartPointer (  const SmartPointer< T > &    sp )  [inline]

Copy constructor; creates a new smart pointer referring to the same object. Increments the reference count of the object. Parameters: sp  an existing reference to an object. This reference may be nil.

template<class T> SmartPointer< T >::~SmartPointer (    )  [inline]

Destructor; release the object (through a call to IotrRelease()) if the object is not nil.

template<class T> SmartPointer< T >::SmartPointer (  T *    t )  [inline]

Allow EXPLICIT conversion from a (T*) to a SmartPointer to T. Implicit conversion is not allowed, because this could have subtle, unintended consequences.

---

Member Function Documentation

template<class T> void SmartPointer< T >::bind (  SmartPointer< T > &    sp, T **    obj )  [inline, static]

Converts a traditional pointer to a smart pointer, destroying the original pointer.

template<class T> T& SmartPointer< T >::operator * (    )  [inline]

Dereferencing operation. Return a reference to the object.

template<class T> SmartPointer< T >::operator T * (    )  [inline]

Automatically convert this object to a traditional pointer to an object that may be passed in as a paramter to function or method calls. For most other purposes SmartPointer::ptr() is more appropriate

template<class T> T* SmartPointer< T >::operator-> (    )  [inline]

Send a message to, or access a data memeber of, the object to which this is a reference.

template<class T> SmartPointer<T>& SmartPointer< T >::operator= (  const SmartPointer< T > &    sp )  [inline]

Assignment operator; cause this SmartPointer to refer to the same object that sp refers to. Parameters: sp  an existing reference to an object. This reference may be nil.

template<class T> T* SmartPointer< T >::ptr (    )  const [inline]

Call SpAsPointer() instead; return a traditional pointer to the underlying object.

template<class T> void SmartPointer< T >::referTo (  SmartPointer< T > &    sp, T *    obj )  [inline, static]

Call SpReferTo() instead of this method; make a SmartPointer refer to the same object as a traditional pointer.

---

Member Data Documentation

template<class T> T* SmartPointer< T >::obj [protected]

a traditional pointer to the object being referenced.

---

The documentation for this class was generated from the following file:

• SmartPointer.h

---