RefCountedPtr< T > Class Template Reference

A reference-counting handle class. More...

#include <RefCountedPtr.H>

Inheritance diagram for RefCountedPtr< T >:

[legend]Collaboration diagram for RefCountedPtr< T >:

[legend]List of all members.

Public Member Functions
	RefCountedPtr (T *ptr=0)
	RefCountedPtr (const RefCountedPtr< T > &other)
	~RefCountedPtr ()
const RefCountedPtr< T > &	operator= (const RefCountedPtr< T > &rhs)
	assignement operator. copies pointer member
T *	operator-> ()
	dereference access operator. use like a pointer derefence access function.
const T *	operator-> () const
bool	isNull () const
T &	operator * ()
	pointer dereference.
const T &	operator * () const
	operator const T * () const
	auto conversion to regular const pointer where required.
bool	isNonUnique () const
	true when refcount is one.
int	refCount () const
Protected Attributes
T *	ptr_
int *	refCount_

---

Detailed Description

template<class T>
class RefCountedPtr< T >

A reference-counting handle class.

This is to be used as a pointer to class T. This will feel and smell just like a built-in pointer except:

1. There is no need to call delete on the pointer.
2. The default copy constructor and assignment implement ref-counting.
3. The user may call isNonUnique to determine if this pointer is the only pointer to the data. This can be used to hide the ref-counting behavior of a class.
4. Checks for dereference of a null pointer.

This class is completely inlined.

typical usage:

{
  Box b;
  IntVect a;
  //refCount() == 1
  RefCounterPtr<IntVectSet> set(new IntVectSet()); 
  
  // still just one IntVectSet, but refCount()==2
  RefCountedPtr<IntVectSet>  otherSet(set);
  
  // Like a pointer, modifying one modifies the other
  otherSet->define(b);
  (*set)|=a;
  {
        RefCountedPtr<IntVectSet> anotherSet; // null
        anotherSet = otherSet ;  //now all three have refCount()==3
  }//anotherSet out of scope, so deleted.  IntVectSet NOT deleted.
  
  // set.refCount() == 2
  // otherSet.refCount() == 2;
  // otherset == set;

}
// when all RefCountedPtr's for a given object are deleted, the last
// one calls 'delete' on the member pointer.

---

Constructor & Destructor Documentation

template<class T> RefCountedPtr< T >::RefCountedPtr (  T *  ptr = 0  )  [inline]

template<class T> RefCountedPtr< T >::RefCountedPtr (  const RefCountedPtr< T > &  other  )  [inline]

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

---

Member Function Documentation

template<class T> bool RefCountedPtr< T >::isNonUnique (   )  const [inline]

true when refcount is one.

template<class T> bool RefCountedPtr< T >::isNull (   )  const [inline]

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

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

pointer dereference.

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

auto conversion to regular const pointer where required.

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

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

dereference access operator. use like a pointer derefence access function.

template<class T> const RefCountedPtr< T > & RefCountedPtr< T >::operator= (  const RefCountedPtr< T > &  rhs  )  [inline]

assignement operator. copies pointer member copies pointer member and integer pointer, decreases refcount of rhs member before assignment. this refcount increased my one.

template<class T> int RefCountedPtr< T >::refCount (   )  const [inline]

---

Member Data Documentation

template<class T> T* RefCountedPtr< T >::ptr_ [protected]

template<class T> int* RefCountedPtr< T >::refCount_ [protected]

---

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

• RefCountedPtr.H

---