Can't throw exception in Template

[Spring08]

I'm making an "improved" array for my programing class. It's currently unfinished, so you might see some commented out code. I'm trying to debug what I have.

I keep getting these errors when I try to complile my main.cpp:
In file included from main.cpp:3:0:
array.h:107:43: error: expected type-specifier before ‘out_of_range’
array.h:107:43: error: expected ‘)’ before ‘out_of_range’
array.h:107:43: error: expected initializer before ‘out_of_range’
array.h:121:55: error: expected type-specifier before ‘out_of_range’
array.h:121:55: error: expected ‘)’ before ‘out_of_range’
array.h:121:55: error: expected initializer before ‘out_of_range’


My main file:

#include <iostream>
#include <stdexcept>
#include "array.h"
using namespace std;
using namespace ArrayNameSpace;

int main()
{
   Array<int> testSubject(5);
   
   return 0;
}//End main 

aannnd my Array.h file:

//ADD CONSTS TO METHODS
//CURRENTLY WORKING ON EXCEPTIONS AND BRACKET[] OVERLOADS.  I HAVE TO FIGURE OUT SOLUTIONS FOR REACHING
//INDEXES FOR CHARS AND ENUMS
#ifndef __array_H__
#define __array_H__
#include <stdexcept>
namespace ArrayNameSpace
{
/************************CLASS DECLERATION****************************
 * *******************************************************************/
template <class T>
class Array
{
   public:
      explicit Array();
      explicit Array(int);
      explicit Array(int, int);
      explicit Array(char, char);
      ~Array();                               //destructor
      Array(const Array&);                     //copy constructor
//      explicit Array(enum enumObject);
      T& operator[](int index);
      const T& operator[](int index) const;
      const Array& operator=(const Array& other);
      
      
   private:
      int arraySize;
      int count;
      int startIndiceInt;
      int endIndiceInt;
      int fillCount;
      char startIndiceChar;
      char endIndiceChar;
      T* theArray;
};//End class defenition

/************************CLASS IMPLEMENTATION*************************
 ***************************CONSTRUCTORS******************************/

template <class T>
Array<T>::Array()
{
   arraySize = 0;
   theArray = new T[arraySize];
   fillCount = 0;
}//End constructor

template <class T>
Array<T>::Array(int n)
{
   arraySize = n;
   theArray= new T[arraySize];
   fillCount = 0;
}//End constructor

template <class T>
Array<T>::Array(int m, int n)
{
   arraySize = n-m+1;
   startIndiceInt = m;
   endIndiceInt = n;
   theArray = new T[arraySize];
   fillCount = 0;
}//End constructor
   
template <class T>
Array<T>::Array(char m, char n)
{
   arraySize = n-m+1;
   startIndiceChar = m;
   endIndiceChar = n;
   theArray = new T[arraySize];
   fillCount = 0;
}//End constructor


/************************CLASS IMPLEMENTATION*************************
 ****************************DESTRUCTORS******************************/
template <class T>
Array<T>::~Array()
{
   delete [] theArray;
   theArray = NULL;
}//End destructor


/************************CLASS IMPLEMENTATION*************************
 *************************COPY CONSTRUCTORS***************************/
template <class T>
Array<T>::Array(const Array<T>& anArray)
{
   arraySize = anArray.arraySize;
   theArray = new T[arraySize];
   count = anArray.count;
   for(int i = 0; i++; i< count)
   {
      theArray[i] = anArray.theArray[i];
   }//End for loop
   
}//End copy constructor


/************************CLASS IMPLEMENTATION*************************
 *************************OPERATOR OVERLOADS**************************/
template <class T>
T& Array<T>::operator[](int index) throw (out_of_range)
{
   // throw an exception if outside the array boundaries
   if (index >= arraySize || index<= 0)
   {
     throw out_of_range( "The given index (" + index + ")" + " does not exist within the Array's boundaries." );
   }
   else
      return theArray[index];
}//End operator overload []

// the following method allows a const pass by reference argument
// For example: void func(const Array& array)
template <class T>
const T& Array<T>::operator[](int index) const throw (out_of_range)
{
//    throw an exception if outside the array boundaries
   if (index >= arraySize || index<= 0)
   {
      throw out_of_range( index + " does not exist within the Array's boundaries." );
   }
   else
      return theArray[index];
}//End operator overload [] const Pass by reference

template <class T>
const Array<T>& Array<T>::operator=(const Array<T>& other)
{
   if( &other == this)
      return *this;
   
   delete [] theArray;
   count = other.count;
   arraySize = other.arraySize;
   theArray = new T[arraySize];
   for(int i = 0; i < count; i++)
   {
      theArray[i] = other.theArray[i];
   }//End for loop
   
   return *this;
}//End operator overload =

}//End ArrayNameSpace
#endif 

I've spent at least a good two hours trying to google solutions

[Peter87]

std::out_of_range

[kbw]

T& Array<T>::operator[](int index) throw (std::out_of_range)

You forgot the namespace.

[Spring08]

Thank you for the prompt response, I appreciate it!