Использование string в шаблоне

template <class T>
class Array {
private:
    static unsigned int size;
    T* ptr = 0;
    unsigned int curr_size;
public:
    Array(T A, int curr_size) {
        this->curr_size = curr_size;
        if (curr_size > 0) {
            ptr = new T[curr_size];
            for (int i = 0; i < curr_size; i++)
                ptr[i] = A;
        }
    }
    ~Array() {
        delete ptr;
    }
    unsigned int _size() const {
        return curr_size;
    }
};

template <class T>
class Array {
private:
    static unsigned int size;
    T* ptr = 0;
    unsigned int curr_size;
public:
    Array(T A, int curr_size) {
        this->curr_size = curr_size;
        if (curr_size > 0) {
            ptr = new T[curr_size];
            for (int i = 0; i < curr_size; i++)
                ptr[i] = A;
        }
    }
    template <class TT>
    Array(TT A, int curr_size) {
        this->curr_size = curr_size;
        if (curr_size > 0) {
            ptr = new T[curr_size];
            for (int i = 0; i < curr_size; i++)
                ptr[i] = A;
        }
    }
    ~Array() {
        delete ptr;
    }
    unsigned int _size() const {
        return curr_size;
    }
};

#include <iostream>
#include <string>
#include <fstream>
using namespace std;
 
class Ratio {
private:
    int n, den;
public:
    Ratio(int a = 1, int b = 1) {
        n = a;
        den = b;
    }
    double get_rat() const {
        if (den == 0)
            throw 123;
        return n / den;
    }
    friend ostream& operator << (ostream&,const Ratio&);
    friend istream& operator >> (istream&, Ratio&);
    friend Ratio operator + (int, Ratio&);
    friend Ratio operator * (int, Ratio&);
 
 
    Ratio operator - (Ratio&);
    void operator *= (Ratio&);
    void operator += (Ratio&);
    void operator *= (int);
    void operator += (int);
 
    Ratio operator + (Ratio&);
    Ratio operator + (int);
 
    Ratio operator * (Ratio&);
    Ratio operator * (int);
};
 
 
istream& operator>>(istream& in, Ratio& R) {
    int den;
    cin >> R.n >> den;
    if (den == 0)
        throw "fail";
    R.den = den;
    return in;
}
ostream& operator << (ostream& out,const Ratio& R) {
    out << R.n << '/' << R.den;
    return out;
}
Ratio Ratio::operator - (Ratio& R) {
    return Ratio(-R.n, -R.den);
}
bool operator > (Ratio& R1, Ratio& R2) {
    return R1.get_rat() > R2.get_rat();
}
bool operator < (Ratio& R1, Ratio& R2) {
    return R1.get_rat() < R2.get_rat();
}
void Ratio::operator*=(Ratio& R) {
    this->n *= R.n;
    this->den *= R.den;
}
void Ratio::operator*=(int val) {
    this->n *= val;
}
void Ratio::operator+=(Ratio& R) {
    this->n *= R.den;
    this->n += R.n * this->den;
    this->den *= R.den;
}
void Ratio::operator+=(int val) {
    this->n += this->den * val;
}
Ratio Ratio::operator + (Ratio& R) {
    return Ratio(this->n * R.den + R.n * this->den, this->den * R.den);
}
Ratio Ratio::operator + (int val) {
    return Ratio(val * this->den + this->n, this->den);
}
Ratio operator + (int val, Ratio& R) {
    return Ratio(val * R.den + R.n, R.den);
}
Ratio Ratio::operator * (Ratio& R) {
    return Ratio(this->n * R.n, this->den * R.den);
}
Ratio Ratio::operator * (int val) {
    return Ratio(val * this->den + this->n, this->den);
}
Ratio operator * (int val, Ratio& R) {
    return Ratio(val * R.den + R.n, R.den);
}
 
template <class T>
class Array {
private:
    static unsigned int size;
    T* ptr = 0;
    unsigned int curr_size;
public:
    Array(int curr_size, T A) {
        this->curr_size = curr_size;
        if (curr_size > 0) {
            ptr = new T[curr_size];
            for (int i = 0; i < curr_size; i++)
                ptr[i] = A;
        }
    }
    ~Array() {
        delete [] ptr;
    }
    unsigned int _size() const {
        return curr_size;
    }
    template<typename U>
    friend istream& operator >> (istream&, Array<U>&);
    template<typename U>
    friend ostream& operator << (ostream&, Array<U>&);
    T operator [] (int n);
    void operator *= (int num);
    void operator += (int num);
};
 
template <class T>
unsigned int Array<T>::size = 256;
template <typename T>
ostream& operator << (ostream& out, Array<T>& A) {
    for(int i=0; i<A._size(); i++)
        out << A[i] << '\n';
    return out;
}
template <class T>
istream& operator >> (istream& in, Array<T>& A) {
    for (int i = 0; i < A._size(); i++)
        in >> A[i];
    return in;
}
template <typename T>
T Array<T>::operator [] (int n) {
    if (n > curr_size || n < 0)
        cout << "Index is out of range";
    else
        return (ptr[n]);
}
template <typename T>
void Array<T>::operator *= (int num) {
    for (int i = 0; i < curr_size; i++)
        ptr[i] *= num;
}
template <typename T>
void Array<T>::operator += (int num) {
    for (int i = 0; i < curr_size; i++)
        ptr[i] += num;
}
 
class NamedArray : public Array<int>
{
private:
    string name;
public:
    NamedArray():Array(0,0) {
        name = "Array";
    }
    NamedArray(int val ,unsigned int size, string name):Array(val, size) {
        this->name = name;
    }
    ~NamedArray() {
        cout << "i AM PUDGE";
    }
    //friend istream& operator >> (istream&, NamedArray&);
    //friend ostream& operator << (ostream&, NamedArray&);
};
/*ostream& operator << (ostream& out, NamedArray& A) {
    for (int i = 0; i < A._size(); i++)
        out << A[i] << '\n';
    return out;
}
istream& operator >> (istream& in, NamedArray& A) {
    for (int i = 0; i < A._size(); i++)
        in >> A[i];
    return in;
}*/
 
int main() {
    Array<int> a(4,6);
    Ratio F(1, 4);
    Array<Ratio> a(F, 4);
}