GrowableArray.h

Go to the documentation of this file.

#ifndef _GROWABLEARRAY_H_
#define _GROWABLEARRAY_H_

#include <stdexcept>

template <class T>
class GrowableArray {
private:
  typedef enum { StartArraySize = 64 } bogus;
  size_t num_elem;     // number of data elements in the array
  size_t array_size;   // array size (e.g., data capacity)
  T *pArray;

private:
  bool twice()
  {
    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


  void init(size_t initialSize )
  {
    array_size = StartArraySize;
    while (initialSize > array_size) {
      array_size = array_size * 2;
    }
    pArray = new T[ array_size ];
    num_elem = initialSize;
  } // init

public:
  GrowableArray()
  {
    init( 0 );
  } // GrowableArray constructor


  GrowableArray(size_t initialSize)
  {
    init( initialSize );
  }

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

  const size_t length(void) const { return num_elem; }

  T &operator[](const size_t i)
    throw(std::out_of_range)
  {
    if (i >= num_elem) {
      const char *errMsg = "1. GrowableArray::[] - index out of bounds";
      throw std::out_of_range(errMsg);
    }
    return pArray[ i ];
  }

  T operator[](const size_t i ) const
    throw(std::out_of_range)
  {
    if (i >= num_elem) {
      const char *errMsg = "2. GrowableArray::[] - index out of bounds";
      throw std::out_of_range(errMsg);
    }
    return pArray[ i ];
  }

  const T *getData() const { return pArray; }

  void append( T item )
    throw(std::runtime_error)
  {

    if (num_elem == array_size) {
      bool allocOK = twice();
      if (!allocOK) {
        const char *errMsg = "GrowableArray::append - memory allocation error";
        throw std::runtime_error( errMsg );
      }
    }

    pArray[ num_elem ] = item;
    num_elem++;
  } // append


  void expand( size_t amount )
    throw(std::runtime_error)
  {
    bool allocOK = true;

    while (allocOK && num_elem + amount >= array_size) {
      allocOK = twice();
      if (!allocOK) {
        const char *errMsg = "GrowableArray::expand - memory allocation error";
        throw std::runtime_error( errMsg );
      }
    }
    num_elem += amount;
  } // expand


  void remove(void)
  {
    if (num_elem > 0)
      num_elem--;
  } // remove

  void set_size( size_t new_size )
  {
    if (new_size <= array_size) {
      num_elem = new_size;
    }
    else { // new_size > array_size
      size_t num_new_elem = new_size - num_elem;
      expand( num_new_elem );
    }
  } // set_size

}; // GrowableArray


#endif

---