// CArray.h

#ifndef __CARRAY_H__
#define __CARRAY_H__

#include <mem.h>

template <class T>
class CArray
{
        public:
        // (default) constructor

        CArray(int ArraySize=1)
        {
            // make sure that array is bigger than 0

            if(ArraySize < 1)
                throw "Error: Invalid Array Size";

            // set array size to desired size

            Size = ArraySize;

            //

            Data = new T[Size];
        }

        // copy constructor

        CArray(CArray<T>& CopyArray)
        {
            // delete data

            delete[] Data;

            // set to null, just to be safe

            Data = NULL;

            // get the new array size

            Size = CopyArray.Elements();

            // reallocate memory for array

            Data = new T[Size];

            // copy the data

            memcpy(Data, NewArray, Memory());
        }

        ~CArray()
        {
            // Delete the data

            delete[] Data;

            // set to null, to be safe

            Data = NULL;

            // no more array, so size is zippo

            Size = 0;
        }

        T& operator[](int Index) const
        {
            if(Index < 0 || Index >= Size)
            {
                throw "Error: CArray bounds exceeded";
            }

            return Data[Index];
        }

        operator T*() const
        {
            return(Data);
        }

        CArray<T>& operator=(const CArray<T>& CopyArray)
        {
            // delete data

            delete[] Data;

            // set to null, just to be safe

            Data = NULL;

            // get the new array size

            Size = CopyArray.Elements();

            // reallocate memory for array

            Data = new T[Size];

            // copy the data

            memcpy(Data, CopyArray, Memory());

            // return this array

            return(*this);
        }

        int Elements() const
        {
            return(Size);
        }

        int Memory() const
        {
            return(Size * sizeof(T));
        }

        protected:
        T* Data;
        int Size;
};

#endif