Проверить на выход за границы массива

template <class T, int size>
T & Array<T, size> :: operator [](int index) {
    try {
    if (index < 0 || index >= currentSize)
        throw out_of_range("Index was out of range");
    }
    catch(...) { // что тут писать чтобы поймать из throw
        cout << "error";
    }
    return aPtr[index]; // и как быть тут куда вставить эту строку
}

template <class T, size_t size>
Array<T, size> & Array<T, size> :: operator = (const Array<T, size> &arrayForAssign) {
    if (this != &arrayForAssign) {
        T *ptr = new T[arrayForAssign.currentSize]; // 1 пункт
        size_t s = arrayForAssign.currentSize;
        try {      // 2 пункт
            for (size_t i = 0; i < arrayForAssign.currentSize; i++) {
                ptr[i] = arrayForAssign.aPtr[i];
            }
            delete [] aPtr;  // 3 пункт если в копировании исключ не сгенерировалось
            currentSize = s;
            maxSize = arrayForAssign.maxSize;
            aPtr = ptr;
            return *this;
        }
        catch(...) {
            delete [] ptr;   
        }  
    }
    return *this;
}

T *ptr = reinterpret_cast<T*>(operator new[](N * sizeof(*ptr)));
///
operator delete[](ptr);

#ifndef Ex_h
#define Ex_h
 
#include <iostream>
#include "TArray.h"
 
using namespace std;
 
template <class T, size_t size> class Array;
 
template <class T, size_t size>
class Ex {
    public:
        Ex(size_t s);
        ~Ex();
        void init(const T &elem, size_t n);
        T * get(void);
 
    private:
        size_t s;
        T *p;
};
 
 
template <class T, size_t size>
Ex<T, size> :: Ex(size_t s) {
    this -> s = s;
    p = reinterpret_cast<T*>(operator new[](s * sizeof(*p)));
}
 
 
template <class T, size_t size>
Ex<T, size> :: ~Ex() {
    //delete [] p;
}
 
 
template <class T, size_t size>
void Ex<T, size> :: init(const T &elem, size_t n) {
    new (p + n) T(elem);
    cout << *(p + n) << " "; 
}
 
 
template <class T, size_t size>
T * Ex<T, size> :: get(void) {
    return p;
}
 
#endif

template <class T, size_t size>
Array<T, size> & Array<T, size> :: operator = (const Array<T, size> &arrayForAssign) {
    if (this != &arrayForAssign) {
        Ex<T, 5> obj(arrayForAssign.currentSize);
        for (size_t i = 0; i < arrayForAssign.currentSize; i++) {
            obj.init(arrayForAssign.aPtr[i], i);
        }       
        delete [] aPtr;
        aPtr = obj.get();
        currentSize = arrayForAssign.currentSize;
        maxSize = arrayForAssign.maxSize;
 
    }
    return *this;
}

size_t i = 0;
try {
    for(; i < size; ++i)
        new(newArray + i) T(srcArray[i]);
} catch (...) {
    for(; i > 0;)
    {
        --i;
        newArray[i].~T();
    }
    deallocate(newArray);
    throw;
}