---

GrowableArray Class Template Reference

A Generic Growable Array. More...

#include <grow_array.h>

List of all members.

Public Methods
	GrowableArray ()
	~GrowableArray ()
const size_t	length (void) const
void	set_to_zero ()
	set array to zero length. More...
T&	operator[] (const size_t i)
	LHS [] operator. More...
T	operator[] (const size_t i) const
	RHS [] operator. More...
const T*	getData () const
void	append (T item)
	append an item to the end of the array. More...
void	expand (size_t amount)
	Expand the array by amount. More...
void	remove (void)
	Remove one item from the end of the array. More...
Private Types
enum	bogus { StartArraySize = 128 }
	The GrowableArray initially starts with array_size = StartArraySize. More...
Private Methods
bool	twice ()
	Double the amount of memory allocated for the array. More...
Private Attributes
size_t	num_elem
	Number of data elements in the array. More...
size_t	array_size
	Number of possible slots for data elements. More...
T*	pArray
	internal data storage array. More...

---

Detailed Description

template<class T> class GrowableArray

A Generic Growable Array.

This file defines an array template class that will grow as elements are added to the end of the array. This is similar to the STL <vector> class.

This array class is designed for dense arrays where the all elements of the array are used.

Usage:

• Elements are added to the end of the array via the append function.

• Elements in the array can be accessed via the [] operator.

• If the elements in the array are dynamicly allocated, the user is responsible for deallocating these elements.

A doubling algorithm is used when the data size is expanded because it minimizes the amount of copying that must be done. The array will quickly grow to a the size needed to accomodate the data set and no more copying will be necessary. For large arrays there is the drawback that more memory may be allocated than is needed, since the amount of memory used grows exponentially.

Example:

  GrowableArray< int > iArray;
  const int numInts = 20;
  
  for (int i = 0; i < numInts; i++)
    {
      iArray.append( i );
    }
  
  const int len = iArray.length();
  int sum = 0;
  
  for (i = 0; i < len; i++) {
    sum = sum + iArray[i];
  }

Parameters:

T	the type of the array elements

---

Member Enumeration Documentation

template<class T> enum GrowableArray<T>::bogus [private]

The GrowableArray initially starts with array_size = StartArraySize. Enumeration values: StartArraySize   { StartArraySize = 128 } bogus;

---

Constructor & Destructor Documentation

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

{ pArray = new T[ StartArraySize ]; num_elem = 0; array_size = StartArraySize; } // GrowableArray constructor

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

{ if (pArray != NULL) { delete [] pArray; } } // GrowableArray destructor

---

Member Function Documentation

template<class T> void GrowableArray<T>::append ( T item ) [inline]

append an item to the end of the array. { if (num_elem == array_size) { bool allocOK = twice(); assert( allocOK ); } pArray[ num_elem ] = item; num_elem++; } // append

template<class T> void GrowableArray<T>::expand ( size_t amount ) [inline]

Expand the array by amount. Expand the number of array data slots by "amount" elements. Note that "array_size" is the total amount of storage available for data slots. "num_elem" is the number of data slots. The bounds over which the array can be indexed is governed by num_elem. Note that after expand() is called the new data elements can be read, but their value is undefined until they are initialized. { bool allocOK = true; while (allocOK && num_elem + amount >= array_size) { allocOK = twice(); assert( allocOK ); } num_elem += amount; } // expand

template<class T> const T * GrowableArray<T>::getData ( ) const [inline]

Returns: a pointer to the internal data { return pArray; }

template<class T> const size_t GrowableArray<T>::length ( void ) const [inline]

Returns: the amount of data in the array (number of elements) { return num_elem; }

template<class T> T GrowableArray<T>::operator[] ( const size_t i ) const [inline]

RHS [] operator. { assert( i < num_elem ); return pArray[ i ]; }

template<class T> T & GrowableArray<T>::operator[] ( const size_t i ) [inline]

LHS [] operator. { assert( i < num_elem ); return pArray[ i ]; }

template<class T> void GrowableArray<T>::remove ( void ) [inline]

Remove one item from the end of the array. { if (num_elem > 0) num_elem--; }

template<class T> void GrowableArray<T>::set_to_zero ( ) [inline]

set array to zero length. { num_elem = 0; }

template<class T> bool GrowableArray<T>::twice ( ) [inline, private]

Double the amount of memory allocated for the array. Returns: true if memory allocation succeeded, false otherwise. { bool rslt; T *old_array = pArray; size_t new_size = array_size * 2; pArray = new T [ new_size ]; if (pArray != 0) { rslt = true; for (int i = 0; i < array_size; i++) { pArray[i] = old_array[i]; } delete [] old_array; array_size = new_size; } else { rslt = false; } return rslt; } // twice

---

Member Data Documentation

template<class T> size_t GrowableArray<T>::array_size [private]

Number of possible slots for data elements.

template<class T> size_t GrowableArray<T>::num_elem [private]

Number of data elements in the array.

template<class T> T * GrowableArray<T>::pArray [private]

internal data storage array.

---

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

• grow_array.h

---