Класс-контейнер стек с итератором

//Структура, состоящая из комплексного числа и математического оператора
struct NumberAndOperator  {
   Complex Number;
   char operate;
};
//КЛАСС СТЕК----------------------------------------------------------------------------------------------
template <typename T>
class Stack
{
private:
   T *stackPtr;                      // указатель на стек
   const int size;                   // максимальное количество элементов в стеке
   int top;                          // номер текущего элемента стека
 
public:
   Stack(int = 10);                  // по умолчанию размер стека равен 10 элементам
   Stack(const Stack<T> &);          // конструктор копирования
   ~Stack();                         // деструктор
 
   void push(const T & );     // поместить элемент в вершину стека
   char OperatorFromStack();  //выделить математический оператор из стека
   Complex pop();                   // удалить элемент из вершины стека и вернуть его
   const T &Peek(int ) const; // n-й элемент от вершины стека
   int getStackSize() const;  // получить размер стека
   T *getPtr() const;         // получить указатель на стек
   int getTop() const;        // получить число элементов в стеке
   void empty();              //удалить все элементы стека
   Complex Calculator();      //подсчёт значения выражения, хранящегося в стеке
};
 
// реализация методов шаблона класса Stack
 
// конструктор Стека
template <typename T>
Stack<T>::Stack(int maxSize) :
   size(maxSize) // инициализация константы
{
   stackPtr = new T[size]; // выделить память под стек
   top = 0; // инициализируем текущий элемент нулем;
}
 
// конструктор копирования
template <typename T>
Stack<T>::Stack(const Stack<T> & otherStack) :
   size(otherStack.getStackSize()) // инициализация константы
{
   stackPtr = new T[size]; // выделить память под новый стек
   top = otherStack.getTop();
 
   for(int ix = 0; ix < top; ix++)
       stackPtr[ix] = otherStack.getPtr()[ix];
}
 
// функция деструктора Стека
template <typename T>
Stack<T>::~Stack()
{
   delete [] stackPtr; // удаляем стек
}
 
// функция добавления элемента в стек
template <typename T>
void Stack<T>::push(const T &value)
{
   // проверяем размер стека
   assert(top < size); // номер текущего элемента должен быть меньше размера стека
 
   stackPtr[top++] = value; // помещаем элемент в стек
}
 
 
//функция выделения математического оператора из стека
template <typename T>
char Stack<T>::OperatorFromStack()
{
   // проверяем размер стека
   assert(top > 0); // номер текущего элемента должен быть больше 0
   NumberAndOperator StructureOp = stackPtr[top - 1];
   char TopOperator = StructureOp.operate;
   return TopOperator;
}
 
 
// функция удаления элемента из стека; возвращает комплексное число, входящее в структуру
template <typename T>
Complex Stack<T>::pop()
{
   // проверяем размер стека
   assert(top > 0); // номер текущего элемента должен быть больше 0
   NumberAndOperator Structure = stackPtr[top - 1];
   Complex TopValue = Structure.Number;
   stackPtr[--top]; // удаляем элемент из стека
   return TopValue;
}
 
// функция возвращает n-й элемент от вершины стека
template <class T>
const T &Stack<T>::Peek(int nom) const
{
 //
 assert(nom <= top);
 
 return stackPtr[top - nom]; // вернуть n-й элемент стека
}
 
 
 
// вернуть размер стека
template <typename T>
int Stack<T>::getStackSize() const
{
   return size;
}
 
// вернуть указатель на стек (для конструктора копирования)
template <typename T>
T *Stack<T>::getPtr() const
{
   return stackPtr;
}
 
// вернуть число элементов стека
template <typename T>
int Stack<T>::getTop() const
{
   return top;
}
//удаление всех элементов стека
template <typename T>
void Stack<T>::empty()
{
   while(top)
       pop();
}
 
//Метод подсчёта значения выражения
template <typename T>
Complex Stack<T>::Calculator()
{   Complex Value;
 
   while(top){
       switch(OperatorFromStack()){
           case '0':
               Value = pop();
               break;
           case '+':
               Value = Value + pop();
               break;
           case '-':
               Value = Value - pop();
               break;
           case '*':
               Value = Value * pop();
               break;
           case '/':
               Value = Value / pop();
               break;
       }
   }
 
   return Value;
}