Перегрузка оператора <<

#include <iostream>
#include <cstdlib>
#include <cassert>
 
#ifndef ARRAY_H
#define ARRAY_H
 
template< class T, class T1 >
class Array{
    friend std::ostream& operator<< ( std::ostream&, Array& );
    friend Array operator+ (Array&, Array&);
public:
    //overload
    T& operator[] ( T1 );                                                       //[] not const
    T& operator[] ( T1 ) const;
    //constructors
    Array( T1 = 1 );
    Array( Array< T, T1 > & );
    //get
    T1 getSize( void ) const;
    //add
    void addArray( const Array< T, T1 >& );
    //another
    std::ostream& show( char, std::ostream & = std::cout );
    //destructor
    ~Array();
private:
    T* data;
    T1 size;
};
 
//constructor
template< class T, class T1 >
Array< T, T1 >::Array( T1 num_of_elements ) {
    assert( num_of_elements > 0 );
    size = num_of_elements;
    data = (T*)realloc( NULL, sizeof(T)*size );
}
 
template< class T, class T1 >
Array< T, T1 >::Array( Array< T, T1 >& ref ) {
    size = ref.getSize();
    data = (T*)realloc(NULL, sizeof(T)*size);
    assert(data!=0);
    //copy
    for ( T1 i = 0; i < size; i++ )
        data[i] = ref[i];
}
 
//add
template< class T, class T1 >
void Array< T, T1 >::addArray( const Array< T, T1 >& ref ) {
    T1 buffer = size;
    size += ref.getSize();
    data = (T*)realloc( data, sizeof(T)*size );
    assert( data != 0 );
    //copy elements
    for (;buffer < size; buffer++) {
        data[buffer] = ref[buffer-ref.getSize()+1];
    }
}
 
//get
template< class T, class T1 >
T1 Array< T, T1 >::getSize( void ) const {
    return size;
}
 
//another
template< class T, class T1 >
std::ostream& Array< T, T1 >::show( char space, std::ostream & output) {
    for ( T1 i = 0; i < size; i++ )
        if ( i < size - 1 )
            output << data[i] << space;
        else
            output << data[i];
 
    return output;
}
 
//overloads
template< class T, class T1 >
std::ostream& operator<< ( std::ostream& output, Array< T, T1 >& ref ){
    return (ref.show(output.fill(), output));
}
 
template< class T, class T1 >
Array< T, T1 > operator+ ( Array< T, T1 >& a1, Array< T, T1 >& a2 ){
    Array< T, T1 > result( a1 );
    result.addArray( a2 );
    return result;
}
 
template< class T, class T1 >
T& Array< T, T1 >::operator[] ( T1 index ) {
    assert( index >= 0 && index < size );
    return data[index];
}
 
template< class T, class T1 >
T& Array< T, T1 >::operator[] ( T1 index ) const {
    assert( index >= 0 && index < size );
    return data[index];
}
 
//destructor
template< class T, class T1 >
Array< T, T1 >::~Array(){
    if (size == 1)
        delete data;
    else
        delete [] data;
}
 
#endif

#include <iostream>
using std::cout;
using std::endl;
using std::cin;
 
#include "Array.h"
 
int main( void ) {
    Array<int, int> a(2);
    a[0] = 1;
    a[1] = 2;
    Array<int, int> b(3);
    b[0] = 3;
    b[1] = 4;
    b[2] = 5;
 
    Array<int, int> c(a);
    c.addArray(b);
 
 
    cout << a;
 
    cin.get();
    cin.get();
    return 0;
}