Hold and delete pointers not deleted by object destructors. More...

#include <PtrHolder.h>

Public Member Functions
	SPtrHolder (T *ptr=0)
	Construct an `SPtrHolder` from a pointer which MUST have been allocated from `new`, since the destructor will After the pointer is placed into the holder, the user should not manually delete the pointer unless the transfer function is called.
	~SPtrHolder ()
void	reset (T *ptr)
	Reset the pointer.
T *	transfer ()
	Transfer ownership of the pointer.
void	release ()
	Release the pointer.
T &	operator* ()
	Make it possible to dereference the pointer object.
const T &	operator* () const
T *	operator-> ()
	Make it possible to use -> on the pointer object.
const T *	operator-> () const
T *	ptr ()
	Get the pointer for use.
const T *	ptr () const
Private Member Functions
	SPtrHolder (const SPtrHolder< T > &other)

SPtrHolder< T > &	operator= (const SPtrHolder< T > &other)
Private Attributes
T *	itsPtr

Detailed Description

template<class T>
class casa::SPtrHolder< T >

Hold and delete pointers not deleted by object destructors.

Intended use:

Public interface

Review Status

Test programs:: tPtrHolder

Prerequisite

module Exceptions

Synopsis

SPtrHolders hold allocated pointers to non-array objects which should be deleted when an exception is thrown. SPtrHolder is similar to PtrHolder, but easier to use and only valid for pointer to a single object, thus not to a C-array of objects.

Example

       void func(Table *ptr); // some other function that takes a pointer
       // ..\.
       // True below means it's an array, False (the default) would mean
       // a singleton object.
       SPtrHolder<Int> iholder(new Table(...));
       func(iholder);                           // converts automatically to ptr
       Table* tab = iholder.transfer();         // transfer ownership

If an exception is thrown in function func, the Table will be deleted automatically. After the function call, the ownership is tranfered back to the 'user'

Motivation

std::autoptr is harder to use and its future is unclear.
PtrHolder is not fully inlined and has C-array overhead. Furthermore the automatic conversion to a T* is dangerous, because the programmer may not be aware that the pointer is maybe taken over.

Definition at line 194 of file PtrHolder.h.

Constructor & Destructor Documentation

template<class T>

casa::SPtrHolder< T >::SPtrHolder ( T * ptr = 0 ) [inline, explicit]

Construct an SPtrHolder from a pointer which MUST have been allocated from new, since the destructor will After the pointer is placed into the holder, the user should not manually delete the pointer unless the transfer function is called.

The pointer must also only be put into one holder to avoid double deletion.

Definition at line 203 of file PtrHolder.h.

template<class T>

casa::SPtrHolder< T >::~SPtrHolder ( ) [inline]

Definition at line 206 of file PtrHolder.h.

References casa::SPtrHolder< T >::itsPtr.

template<class T>

casa::SPtrHolder< T >::SPtrHolder ( const SPtrHolder< T > & other ) [private]