C++ dynamic array template class

 
#include <cstdlib>
 
template<class el>
class AeDynArray
{
public:
    AeDynArray(); // constructor 
    AeDynArray(const AeDynArray &a); // copy constructor 
    ~AeDynArray(); // distructor 
    AeDynArray& operator = (const AeDynArray &a); // assignment operator 
 
    el& operator [] (unsigned int index); // get array item 
    void Add(const el &item); // Add item to the end of array 
 
    unsigned int GetSize(); // get size of array (elements)
    void SetSize(unsigned int newsize); // set size of array (elements)
    void Clear(); // clear array
    void Delete(unsigned int pos); // delete array item 
	void* getptr(); // get void* pointer to array data
 
    enum exception { MEMFAIL }; // exception enum 
 
private:
    el *array; // pointer for array's memory 
    unsigned int size; // size of array (elemets)
    unsigned int realsize; // actual size of allocated memory  
 
	const static int dyn_array_step = 128; // initial size of array memory (elements)
	const static int dyn_array_mult = 2; // multiplier (enlarge array memory 
										 // dyn_array_mult times  )
};
 
//////////////////////////////////////////////////////////////////////
 
template <class el>
AeDynArray<el>::AeDynArray()
{
    realsize = dyn_array_step; // First, allocate step 
							   // for dyn_array_step items
    size = 0;
    array = (el *)malloc(realsize*sizeof(el));
 
    if (array == NULL)
		throw MEMFAIL;
}
 
 
template <class el>
AeDynArray<el>::~AeDynArray()
{
    if (array)
    {
    	free(array); // Freeing memory 
    	array = NULL;
    }
}
 
 
template <class el>
AeDynArray<el>::AeDynArray(const AeDynArray &a)
{
    array = (el *)malloc(sizeof(el)*a.realsize);
    if (array == NULL)
		throw MEMFAIL;
 
    memcpy(array, a.array, sizeof(el)*a.realsize);
	// memcpy call -- coping memory contents 
    realsize = a.realsize;
    size = a.size;
}
 
 
template <class el>
AeDynArray<el>& AeDynArray<el>::operator = (const AeDynArray &a)
{
    if (this == &a) // in case somebody tries assign array to itself 
		return *this;
 
	if (a.size == 0) // is other array is empty -- clear this array 
		Clear();
 
	SetSize(a.size); // set size 
 
    memcpy(array, a.array, sizeof(el)*a.size);
 
    return *this;
}
 
template <class el>
unsigned int AeDynArray<el>::GetSize()
{
    return size; // simply return size
}
 
 
template <class el>
void AeDynArray<el>::SetSize(unsigned int newsize)
{
    size = newsize;
 
	if (size != 0)
	{
		// change array memory size 
		// if new size is larger than current 
		// or new size is less then half of the current 
		if ((size > realsize) || (size < realsize/2))
		{
	    	realsize = size;
	    	array = (el *)realloc(array, sizeof(el)*size);
 
			if (array == NULL)
				throw MEMFAIL;
		}
	}
	else
		Clear();
}
 
template <class el>
void AeDynArray<el>::Delete(unsigned int pos)
{
	if (size == 1) // If array has only one element 
		Clear(); // than we clear it, since it will be deleted 
	else
	{
		// otherwise, shift array elements 
		for(unsigned int i=pos; i<size-1; i++) 
			array[i] = array[i+1];
 
		// decrease array size
		size--;
	}
}
 
template <class el>
void AeDynArray<el>::Clear() // clear array memory 
{
    size = 0; 
	array = (el *)realloc(array, sizeof(el)*dyn_array_step); 
				  // set initial memory size again 
	realsize = dyn_array_step;
}
 
template <class el>
void* AeDynArray<el>::getptr()
{
    return array; // return void* pointer 
}
 
template <class el>
el& AeDynArray<el>::operator [] (unsigned int index)
{
    return array[index]; // return array element 
}
 
template <class el>
void AeDynArray<el>::Add(const el &item)
{
    size++;
 
    if (size > realsize)
    {
		realsize *= dyn_array_mult;
 
		array = (el *)realloc(array, sizeof(el)*realsize);
 
		if (array == NULL)
			throw MEMFAIL;
    }
 
	array[size-1] = item;
}
 
 

 
#include "aedynarray.h"
#include <iostream>
 
using namespace std;
 
// function for outputting array items 
void output_array(AeDynArray<int> &array)
{
	for(unsigned int i=0; i<array.GetSize(); i++)
		cout << array[i] << ", ";
 
	cout << endl; 
}
 
int main(void) 
{
    AeDynArray<int> array;
 
	// setting array size 
	array.SetSize(15);
 
	// filling array with pseudo-random values 
	for(unsigned int i=0; i<15; i++)
		array[i] = rand() % 100;
 
	// lets add some values using Add()
	array.Add(7);
	array.Add(94);
	array.Add(1);
 
	// output all array items
	output_array(array);
 
	// delete 1-st  and last items 
	array.Delete(0);
	array.Delete(array.GetSize() - 1);
 
	// output all array items (again)
	output_array(array);
 
	// let's sort all array items using extemly ineffective sort
	for(unsigned int i=0; i<array.GetSize();) 
		if (array[i] > array[i+1])
		{
			int x = array[i];
			array[i] = array[i+1];
			array[i+1] = x;
			i = 0;
			continue;
		}
		else 
			i++;
 
	output_array(array);			
 
	// create another array, based on first 
	AeDynArray<int> array2(array); 
	array2.Clear(); // clear it
 
	// check multiple addition
	for(int i=0; i<1000000; i++)
		array2.Add(rand()); 
 
	// check assigment operator 
	array = array2;
 
	// output array
	cout << "array 2 size " << array2.GetSize() << endl;
	cout << "array 1 size " << array.GetSize() << endl;
 
	// check random element
	int testel = rand() % 1000000;
	cout << "array 2 element " << testel << " = " << array2[testel] << endl;
	cout << "array 1 element " << testel << " = " << array[testel] << endl;
 
	// that's all! 
	return 0;
}