Создать класс динамического массива

#include <iostream>
#include <initializer_list>
#include <algorithm>
#include <stdexcept>
#include <iterator>
#include <fstream>
 
template<typename T>
class Array
{
private:
    T* par;
    std::size_t parSize;
public:
    typedef T value_type;
    Array() : par(nullptr), parSize(0){}
    Array(std::initializer_list<T> l) : parSize(l.size()), par(new T[l.size()])
    {
        std::copy(l.begin(), l.end(), par);
    }
    Array(const Array& ar) : parSize(ar.parSize), par(ar.par ? new T[ar.parSize] : nullptr)
    {
        if(par)
        {
            std::copy(ar.par, ar.par + ar.parSize, par);
        }
    }
    Array(Array&& ar) : parSize(ar.parSize), par(ar.par)
    {
        ar.par = nullptr;
    }
    Array& operator=(const Array& ar)
    {
        if(this != &ar)
        {
            parSize = ar.parSize;
            delete[] par;
            if(!ar.par) par = nullptr;
            else
            {
                par = new T[ar.parSize];
                std::copy(ar.par, ar.par + ar.parSize, par);
            }
        }
        return *this;
    }
    Array& operator=(Array&& ar)
    {
        std::cout << "Move operator=()\n";
        parSize = ar.parSize;
        delete[] par;
        par = ar.par;
        ar.par = nullptr;
        return *this;
    }
    T& operator[](std::size_t ind)
    {
        if(ind >= parSize) throw std::out_of_range("given index >= parSize");
        else return par[ind];
    }
    const T& operator[](std::size_t ind) const
    {
        if(ind >= parSize) throw std::out_of_range("given index >= parSize");
        else return par[ind];
    }
    void push_back(const T& val)
    {
        ++parSize;
        T* pTmp = par;
        par = new T[parSize];
        std::copy(pTmp, pTmp + parSize - 1, par);
        delete[] pTmp;
        par[parSize - 1] = val;
    }
    std::size_t size() const
    {
        return parSize;
    }
    const T* data() const
    {
        return par;
    }
    virtual ~Array()
    {
        delete[] par;
    }
};
 
template<class T>
std::istream& operator>>(std::istream& is, Array<T>& ar)
{
    std::copy((std::istream_iterator<T>(is)), std::istream_iterator<T>(), std::back_inserter<Array<T>>(ar));
    return is;
}
 
template<class T>
std::ostream& operator<<(std::ostream& os, const Array<T>& ar)
{
    std::copy(ar.data(), ar.data() + ar.size(), std::ostream_iterator<T>(os, "  "));
    return os;
}
 
int main()
{
    Array<int> ar1{11, 21, 31}, ar2(ar1);
    ar2 = Array<int>{22, 23, 24, 25};
    ar2.push_back(100);
    ar2.push_back(105);
    std::cin >> ar2;
    std::cout << "ar2 : "<< ar2 << std::endl;
    std::ifstream ifs("1.txt");
    if(ifs)
    {
        ifs >> ar2;
        std::cout << ar2 << std::endl;
    }
    else std::cerr << "Can't open in file\n";
    ifs.close();
    std::ofstream ofs("2.txt");
    if(ofs)
    {
        ofs << ar2;
    }
    else std::cerr << "Can't open out file\n";
    ofs.close();
    return 0;
}