Создание шаблона с перегрузкой стандартных операторов

#include <iostream>
using namespace std;
 
template <typename T>
class Array
{
 
private:
    int _size;
//    int *_pia;
    T *_pia;
 
public:
//    static int CountOfIntArray;
 
    Array<T>(int sz = 12);
    Array<T>(const Array &ref);
    Array<T>(int size, const T *ia);
 
    Array<T>& operator[](int ind);
    Array<T>& operator= (const Array<T> &source);
    bool operator ==(const Array<T> &source);
 
    void printState(void);
    int getSize() const;
    int countOfNum (const int num);
    ~Array();
};

#include "intarray.h"
#include <iostream>
using namespace std;
 
template <typename T>
Array<T>::Array(int sz)
{
    this->_size = sz;
    this->_pia = new T[this->s];
 
    for(int i = 0; i<sz; i++)
    {
        this->_pia[i] = 0;
    }
 
    //CountOfIntArray++;
    cout << "Array of 10 elements was created" << endl;
}
 
template <typename T>
Array<T>::Array(const Array &ref)
{
    this->s = ref._size;
 
    this->_pia = new T[this->s];
    for (int i = 0; i<this->s; i++)
    {
        this->_pia[i] = ref._pia[i];
    }
 
    cout << "New array of "<< this->s << "elements was created, and initial from another array" << endl;
}
 
template <typename T>
Array<T>::Array(int size, const T *ia)
{
    this->s = size;
    this->_pia = new T[size];
 
    for (int i = 0; i<size; i++)
    {
        this->_pia[i] = ia[i];
    }
 
    cout << "New array of "<< this->s << "elements was created, and initial from another array" << endl;
 
}
 
template <typename T>
Array<T>& Array<T>::operator[] (int ind)
{
    return this->_pia[ind];
}
 
template <typename T>
Array<T>& Array<T>::operator= (const Array<T> &source)
{
    if(source._pia != this->_pia)
        delete[] this->_pia;
 
    this->s = source._size;
    this->_pia = new T[this->s];
 
    for (int i = 0; i<this->s; i++)
    {
        this->_pia[i] = source._pia[i];
    }
 
    return *this;
}
 
template <typename T>
bool Array<T>::operator ==(const Array<T> &source)
{
    if(source._size != this->_size)
        return false;
 
    for(int i=0; i<source._size; i++)
    {
        if(source._pia[i] != this->_pia[i])
            return false;
    }
 
    return true;
}
 
template <typename T>
void Array<T>::printState(void)
{
    cout << "\n<========================>\n" << endl;
 
    for(int i = 0; i<this->_size; i++)
    {
        cout << this->_pia[i] << endl;
    }
 
    cout << "\n<========================>\n" << endl;
}
 
template <typename T>
int Array<T>::getSize() const
{
    cout << "Size of array = "<<this->_size << endl;
    return this->_size;
}
 
template <typename T>
int Array<T>::countOfNum(const int num)
{
    int localCounter = 0;
 
    for(int i=0; i<this->_size; i++)
    {
        if(this->_pia[i] == num)
            localCounter++;
    }
 
    cout << "Count of num ["<<num<<"] is => " << localCounter<<endl;
    return localCounter;
}
 
template <typename T>
Array<T>::~Array()
{
    cout << "Memory cleaned" << endl;
//    CountOfIntArray--;
    delete[] this->_pia;
}

#include <QtCore/QCoreApplication>
#include <iostream>
#include "header.h"
 
using namespace std;
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    
    Array <int> arr1;
    arr1.printState();
    arr1.getSize();
    arr1.countOfNum(1);
 
    return a.exec();
}