Brain problems

// array.cpp
#ifndef _UTIL_ARRAY_CPP_
#define _UTIL_ARRAY_CPP_

#include "array.h"

namespace util{


/**
 * Default constructor
 * \param s The initial size of the array
 */
template <class T>
array<T>::array()
	:	size(0), space(0), arr(NULL)
{
	
}

/**
 * Constructor
 * \param s The initial size of the array
 */
template <class T>
array<T>::array(unsigned int s)
	:	size(s), space(0), arr(NULL)
{
	resize(s);
}

/**
 * Destructor
 */
template <class T>
array<T>::~array()
{
	delete arr;
}

/**
 * Overloaded operator []
 * \param n The index into the array
 * \return A reference to the 'n-1'th object in the array
 */
template <class T>
T& array<T>::operator[](unsigned int n)
{
	return arr[n];
}

/**
 * Delete the array and sets the size to 0
 */
template <class T>
void array<T>::clear()
{
	delete arr;
	arr = NULL;
	size = 0;
}

/**
 * Resize the array to size s.
 * \param s The new size of the array
 */
template <class T>
void array<T>::resize(unsigned int s)
{
	// if re-size fits in currently reserved memory
	if( s <= space ){
		size = s;	// set size of array
		return;
	}

	// else re-size does NOT fit in currenlty reserved memory
	reserve(s);		// allocate 's' amount of memory
	size = s;		// set size of array
	// by this point, size should equal space     29/08/05
}

/**
 * Allocates this amount of memory for the array.
 * If s < size of the array (different to amount of memory allocated) then the array is cut down.
 */
template <class T>
void array<T>::reserve(unsigned int s)
{
	T* temp;
	int tmp;

	// if the array doesn't exist yet
	if( !arr ){
		arr = new T[s];
		space = s;
		return;
	}

	// if param is the same value as current space, ignore
	if( s == space )
		return;

	temp = new T[s];	// new array

	// the number of elements that has to be looped through to
	// copy the elements of the array
	if( s >= size ){
		tmp = size;
		space = s;			// set amount of elements reserved in memory
	}
	else if( s < size ){
		tmp = s;
		size = space = s;	// set size of array and amount of elements reserved in memory
	}

	for(int i=0; i < tmp; i++)
		temp = arr;

	delete arr;		// delete old array
	arr = temp;		// assign new array
}

/**
 * Add an element to the back of the array.
 * \param n A const reference to an object of type T
 */
template <class T>
void array<T>::push_back(const T& n)
{
	int temp = size;// this stores the current position to push_back to in case
		// some re-sizing needs to be done ('size' variable changes, and an array element is skipped)

	// 30-08-05 - FIXME - at some point during previous insertions, 'size' becomes greater than 'space'
	// element to insert into is 'size'
	if( size == space )
		resize( size + 1 );// only adding one at the moment
		
	arr[temp] = n;	// assign T object
	size++;			// increase size
}

}//namespace util
#endif

// array.h
#ifndef _UTIL_ARRAY_H_
#define _UTIL_ARRAY_H_
namespace util{

/**
 * This class defines a wrapper for a templated dynamic array.
 */
template <class T>
class array
{
private:

	unsigned int space;		///< The number of array elements allocated in memory
	unsigned int size;		///< The size of the array
	T* arr;					///< Pointer to the array

public:

	/**
	 * Default constructor
	 */
	array();

	/**
	 * Constructor
	 * \param s The initial size of the array
	 */
	array(unsigned int s);

	/**
	 * Destructor
	 */
	~array();

	/**
	 * Overloaded operator []
	 * \param n The index into the array
	 * \return A reference to the 'n-1'th object in the array
	 */
	T& operator[](unsigned int n);

	/**
	 * Delete the array and sets the size to 0
	 */
	void clear();

	/**
	 * Resize the array to size s.
	 * \param s The new size of the array
	 */
	void resize(unsigned int s);

	/**
	 * Allocates this amount of memory for the array.
	 * If s < size of the array (different to amount of memory allocated) then the array is cut down.
	 */
	void reserve(unsigned int s);

	/**
	 * Returns the size of the array.
	 * \return The current size of the array.
	 */
	unsigned int getSize()	{	return size;	}

	/**
	 * Return the pointer to the array.
	 * \return The address of the array
	 */
	T* getPtr() const	{	return arr;	}

	/**
	 * Add an element to the back of the array.
	 * \param n A const reference to an object of type T
	 */
	void push_back(const T& n);

};
}// namespace util
#endif

// test.cpp

#include <iostream>
using namespace std;


#include "util\array.h"
#include "util\array.cpp"

int main()
{

	util::array<int> a;
	a.reserve(5);
	a.resize(2);

	// by this point, 2 array elements exist
	a.push_back(0);
	a.push_back(1);
	a.push_back(2);
	a.push_back(3);
	a.push_back(4);
	a.push_back(5);
	a.push_back(6);
	a.push_back(7);

	for(int i=0; i < a.getSize(); i++)
		cout << "Arr el["<<i<<"]: " << a << endl;

return 0;
}