overloaded operators question

I'm just trying to get a handle on the when and why of overloaded operators.

I the following snippet:
the line: T& operator[] ... is there for use in the copy constructor?

the line : const T& operator [] ... is there for the constructor definition?

In english, the code is instructing the compiler to return an array pointer of pType[] when encountering an array refernce from T.

this is what enables the program to be versatile by being able to select different array types to be displayed?

the line:
Array<T>& Array<T>: operator=(const Array &rhs)
is there to enable the seleted array to be passed into a template reference? Is this the only way to do it?

Code:

template <class T >
class Array;

template <class T>
ostream& operator << (ostream& , Array<T>& );
template <class T> //declare the template and the parameter
class Array       // the class being paramterized


{
    public:
        //costrucyors
        Array(int itsSize = DefaultSize);
        Array(const Array &rhs);
        ~Array() {delete [] ptype;}

        //operators
        Array& operator = (const Array&);
        T& operator [] (int offset) {return ptype[offset];}
        const T& operator[] (int offset) const
        {return ptype[offset];}
        //accessors
        int GetSize() const {return itsSize;}

        friend ostream& operator << <> (ostream&, Array<T>&);



    private :
        T *ptype;
        int itsSize;
};


template <class T >
ostream& operator << (ostream& output, Array<T>& theArray)


{
    for (int i = 0; i < theArray.itsSize; i++)
      output << "[" << i << "]" << theArray[i] <<endl;

    return output;
}

//implementations follow...

//implement the constructor
template <class T>
Array<T>::Array(int size):
itsSize(size)
{
    ptype = new T[size];
    //the constructors of the type created
    //should be of default value
}

//copy constructor
template <class T>
Array<T>::Array(const Array &rhs)
{
    itsSize =rhs.GetSize();
    ptype = new T[itsSize];
    for (int i=0; i<itsSize; i++)
        ptype[i] = rhs[i];
}
//operator=

template <class T>
Array<T>& Array<T>::operator=(const Array &rhs)
{
    if (this == &rhs)
        return *this;
    delete [] ptype;
    itsSize = rhs.GetSize();
    ptype = new T[itsSize];
    for (int i =0; i<itsSize; i++)
        ptype[i] =rhs[i];
    return *this;
}