Вопрос в шаблонах

template<class T>
class AStack
{
public:
  typedef unsigned int  UINT;
  // конструкторы/копирование/деструктор
  AStack(const T& t = T())
  {
      for(UINT i=0;i<t.Size;i++)
      elems=t;
  }
  AStack(const UINT &n, T k)
  {
    if (Size > 0)                      
    {  
        Count = Size = n;          // размер массива
        elems = new T[Count];       // создали массив
        for(UINT i = 0; i<Count; ++i)       // заполняем массив
        elems = k;                   // значение по умолчанию
    }
    else  throw std::out_of_range("Выход за границу массива");
  }
  AStack(T* first, T* last)
  {
     if (first < last)
     {
         Count = Size = (last - first);  // количество элементов
                 elems = new T[Count];        // создаем массив
         for(UINT i = 0; i<Count; ++i)          // заполняем массив
         elems = *(first+i);     // копируем из массива
     }
     else throw std::range_error("неверная последовательность");
  }
  AStack(const AStack &t, UINT begin, UINT n)
  {
    if (begin<t.size()&&(n<=t.size()-begin))
           {
                  Count = n;    // количество элементов
                  elems = new T[Count];             // создаем массив
                  for(UINT i = 0; i<Count; ++i)   // заполняем массив
           elems = t.elems[i+begin];
    }
    else  throw std::range_error("выход за границу");
  }
  AStack(T z[], const UINT& n)
  {
            Count=Size=n;
     elems=new T[Count];
     for(UINT i=0; i<Count; ++i)
     elems=z;
  }
  AStack(const AStack &t)
  {
     this->Count = t.Count;
     this->elems = new T[Count];                // новый массив
     for(UINT i = 0; i<Count; ++i)              // копируем
     elems = t.elems;
  }
  virtual ~AStack()  {  delete[]elems; elems =0; }
  AStack& operator=(const AStack &t)
  {
    if (this != &t)                          
    {
          Count = t.Count;                             // опеределили размер
          T *new_elems = new T[Count];
          for(UINT i = 0; i<Count; ++i)
          new_elems = t.elems;                   // копируем
          delete[] elems;                              // вернули предыдущий массив
          elems = new_elems;                           // вступили во владение
    }
    return *this;
  }
  // итераторы
  T* begin() { return elems; }
  const T* begin() const { return elems; }
  T* end() { return elems+Count; }
  const T* end() const { return elems+Count; }
  class Iterator  //класс - Итератор
  {
      friend class AStack<T>;
  private:
      T * el;
  public:
      Iterator(const Iterator& t) { t.el=el; }
      Iterator():el(0) {}
      void operator++(){/*.....*/}
      void operator--(){/*......*/}
      bool operator==(const Iterator &t){/*.....*/}
      bool operator!=(const Iterator &t){/*.....*/}
  };
  // размеры
 
   UINT size() const {return Count;}
   UINT capacity() const {return Size;}
   void resize(UINT newsize)
   {
    if(newsize > capacity())
    {
        T* elems1=new T[newsize];
        for(UINT i=0; i<size(); ++i)
        elems1=elems;
        delete[] elems;
        elems=elems1;
        Size=newsize;
    }
    else throw std::bad_alloc("Новый размер меньше текущего!");
   }
   bool empty() const
   {
       if(Count==0) return true;
       else return false;
   }
  // доступ к элементам
  T& operator [](UINT index) //throw(std::range_error)
  {
    if (index<Count) return elems[index];
    else throw std::out_of_range("выход за границу");
  }
  const T& operator [](UINT index) const //throw(std::range_error)
  {
    if(index <Count) return elems[index];
    else throw std::out_of_range("выход за границу");
  }
  T& front() { return elems[0]; }
  const T& front() const { return elems[0]; }
  T& back() { return elems[size()-1]; }
  const T& back() const { return elems[size()-1]; }
  // методы-модификаторы  
  void push_back(const T& v)
  {
      if(Count==Size) resize(Size*2);
      elems[Count++]=v;
  }
  void pop_front()
  {
    if(empty()) throw std::invalid_argument("Error void pop_back(): Array is empty");
    for (UINT i=1; i<Count; i++) elems[i-1]=elems;
    Count--;
  }
  void clear() { Count = 0; }                  // очистить массив
  //void swap(Array& other);                     // обменять с другим массивом
  //void assign(const value_type& v);            // заполнить массив
  friend ostream& operator <<( ostream& p, const AStack& t)
  {
     for(UINT i=0; i<t.size(); ++i)
     p<<t.elems<<" ";
     return p;
  }
private:
  static const UINT minsize = 10;         // минимальный размер массива
  static const UINT maxsize=50;
  UINT Size;                              // выделено элементов в памяти
  UINT Count;                             // количество элементов в массиве
  T * elems;                          // указатель на данные

};