TEMPLATE и Файлове

<pre><div class="text_to_html">#pragma once
#include<iostream>
//10.   ��������� ���� � ���� - ����� �� ��������
//char � double � ������������ ���� - �������,
//���� �� ����� ����� �� ����� �� ���� �� ��
//�������� ��������� -
//������ �� ���. 9 � ������ ����.
template <typename T> class TstClass{
private:
    T * arr;
    size_t sz;

public:
    //big 5
    TstClass(T * = NULL, size_t = 0);
    ~TstClass();
    TstClass(const TstClass&);
    TstClass& operator =(const TstClass&);

    T& operator [](size_t);
    //inserter and extractor
    std::ostream& insOut(std::ostream&) const;
    std::istream& extrIn(std::istream&);

};


//class
template <typename T>
TstClass<T>::TstClass(T * arrName, size_t sz)
    :arr(new T[sz]), sz(sz){
    for (size_t i = 0; i < sz; i++)
    {
        arr[i] = arrName[i];
    }
}

template <typename T>
TstClass<T>::~TstClass(){
    delete[] arr;
}

template <typename T>
TstClass<T>::TstClass(const TstClass& right)
:sz(right.sz),arr(new T[sz]){

    for (size_t i = 0; i < sz; i++)
    {
        arr[i] = right.arr[i];
    }
}

template <typename T>
TstClass<T>& TstClass<T>::operator =(const TstClass<T>& right){
    if (this != &right){
        sz = right.sz;
        for (size_t i = 0; i < sz; i++)
        {
            arr[i] = right.arr[i];
        }
    }
    return *this;
}

template <typename T>
T& TstClass<T>::operator [](size_t index){
    if (index>0 || index < sz){
        return arr[index];
    }
    else{
        std::cerr << "Wrong index!" << std::endl;
        return 0;
    }
}

//inserter and extractor
template <typename T>
std::ostream& TstClass<T>::insOut(std::ostream& out) const{
    out << "(" << arr[0];
    for (size_t i = 1; i < sz; i++)
    {
        out << ", " << arr[i];
    }
    return out << ")";
}

template <typename T>
std::istream& TstClass<T>::extrIn(std::istream& in){
    for (size_t i = 0; i < sz; i++)
    {
        in >> arr[i];
    }
    return in;
}


//�������� ���a�� �������� ����-�����
template<class T>
std::ostream& operator <<(std::ostream& out,
    const TstClass<T> &object){
    return object.insOut(out);
}
template<class T>
std::istream& operator >>(std::istream& in,
    TstClass<T>& object){
    return object.extrIn(in);
}</div></pre>