PtrHolder.h
Classes
- PtrHolder -- Hold and delete pointers not deleted by object destructors (full description)
template<class T> class PtrHolder
Interface
- Public Members
- PtrHolder()
- PtrHolder(T *pointer, Bool isCArray = False)
- ~PtrHolder()
- void set(T *pointer, Bool isCarray = False, Bool deleteCurrentPtr = True)
- void clear(Bool deleteCurrentPtr = True)
- T *ptr()
- const T *ptr() const
- Bool isCArray() const
- Private Members
- PtrHolder(const PtrHolder<T> &other)
- PtrHolder<T> &operator=(const PtrHolder<T> &other)
- void delete_pointer_if_necessary()
Review Status
- Reviewed By:
- troberts
- Date Reviewed:
- 1995/07/29
- Programs:
- Tests:
Prerequisite
Synopsis
PtrHolders hold allocated pointers which should be
deleted when an exception is thrown. Exceptions only call destructors
of objects. Thus, for example, storage allocated in a global function
(outside of an object)is not deleted. A PtrHolder solves
this problem: it merely holds the pointer and deletes it when it is
destroyed itself, e.g. when an exception is thrown or when the
function exits normally.
Example
void func(Int *ptr); // some other function that takes a pointer
// ...
// True below means it's an array, False (the default) would mean
// a singleton object.
PtrHolder<Int> iholder(new Int[10000], True);
func(iholder); // converts automatically to ptr
(iholder.ptr() + 5) = 11; // use pointer explicitly
some_function_that_throws_exception(); // pointer is deleted
Motivation
Avoid leaks when throwing/catching exceptions.
To Do
- Use the autoptr class from the Standard Library
Member Description
The default constructor uses a null pointer.
PtrHolder(T *pointer, Bool isCArray = False)
Construct a PtrHolder from a pointer which MUST have
been allocated from new, since the destructor will
call delete on it. If the pointer is to an array,
i.e. allocated with operator new[], then
isCarray should be set to True. (This parameter is
required because C-arrays need to be deleted with
delete[].)
After the pointer is placed into the holder, the user should
not manually delete the pointer; the PtrHolder
object will do that, unless set() or
clear() is called with deleteCurrentPtr
set to False. The pointer must also only be put into
one holder to avoid double deletion.
void set(T *pointer, Bool isCarray = False, Bool deleteCurrentPtr = True)
Set the pointer to a new value. If deleteCurrentPtr is
True (the default), then delete the existing pointer first. If
isCarray is True, then the new pointer is assumed to
have been allocated with new[].
void clear(Bool deleteCurrentPtr = True)
Set the current pointer to null; if deletePtr is True
(the default), then the current pointer is deleted first.
T *ptr()
const T *ptr() const
Attempt to automatically release a pointer when required. If the
compiler can't figure it out, you can use the ptr()
member function directly.
See if the pointer points to a C-array.
PtrHolder(const PtrHolder<T> &other)
PtrHolder<T> &operator=(const PtrHolder<T> &other)