为什么不能计算带括号的式子？

Question

运行普通算式可以但是不能计算带括号的式子，这是怎么回事？
源文件：

#include<iostream.h>
#include<ctype.h>
#include"stack.h"
#include"mathoptr.h"
int isoperator(char ch)
{
    return(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='(');
}
int iswhitespace(char ch)
{
    return(ch==32||ch=='\t'||ch=='\n');
}
void Error(char *c)
{
    cerr<<c<<endl;
    exit(1);
}
void Evaluate(Stack<double>& Opnds,MathOperator optr)
{
    double opnd1=Opnds.Pop();
    double opnd2=Opnds.Pop();
    switch(optr.op)
    {
    case'+':Opnds.Push(opnd2+opnd1);break;
    case'-':Opnds.Push(opnd2-opnd1);break;
    case'*':Opnds.Push(opnd2*opnd1);break;
    case'/':Opnds.Push(opnd2/opnd1);break;
    }
}
int main()
{
    int rank=0;
    char ch;
    double number;
    MathOperator optr1,optr2;
    Stack<double>opnds;
    Stack<MathOperator>optrs;
    cout<<"input an infix:"<<endl;
    while(cin.get(ch)&&ch!='=')
    {
        if(isdigit(ch)||ch=='.')
        {
            cin.putback(ch);
            cin>>number;
            rank++;
            if(rank>1)
                Error("Operator expected!");
            opnds.Push(number);
        }
        else if(isoperator(ch))
        {
            if(ch!='(')
            {
                rank--;
            }
            if(rank<0)
                Error("Operator ecpected!");
            optr1=MathOperator(ch);
            while(!optrs.Empty()&&optrs.Top()>=optr1)
            {
                optr2=optrs.Pop();
                Evaluate(opnds,optr2);
            }
            optrs.Push(optr1);
        }
        else if(ch==')')
        {
            optr1=MathOperator(ch);
            while(!optrs.Empty()&&optrs.Top()>=optr1)
            {
                optr2=optrs.Pop();
                Evaluate(opnds,optr2);
            }
            if(optrs.Empty())
            {
                Error("Missing left parenthesis");
            }
            optrs.Pop();
        }
        else if(!iswhitespace(ch))
            Error("Invalid input!");
    }
    if(rank!=1)
        Error("operator expected!");
    while(!optrs.Empty())
    {
        optr2=optrs.Pop();
        if(optr2.op=='(')
            Error("Missing right paernthesis");
        Evaluate(opnds,optr2);
    }
    cout<<"The value is "<<opnds.Pop()<<endl;
    return 0;
}

两头文件：

#include<stdlib.h>
template <class T>
class List
{
private:
    struct Node
    {
        T data;
        Node * prev,*next;
        Node(const T &d=T(),Node *p=NULL,Node *n=NULL):data(d),prev(p),next(n){}
    };
    int size;
    Node* head;
    Node* tail;
    void Init()
    {size=0;head=new Node;tail=new Node;head->next=tail;tail->prev=head;}
public:
    class const_iterator
    {
    protected:
        Node *current;
        T& retrieve()const{return current->data;}
        const_iterator(Node *p):current(p){}
        friend class List<T>;
    public:
        const_iterator():current(NULL){}
        const T& operator*()const{return retrieve();}
        const_iterator& operator++()
        {
            current=current->next;
            return *this;
        }
        const_iterator operator++(int)
        {
            const_iterator old=*this;
            ++(*this);
            return old;
        }
        const_iterator& operator--()
        {
            current->prev;
            return *this;
        }
        const_iterator operator--(int)
        {
            const_iterator old=*this;
            --(*this);
            return old;
        }
        bool operator==(const const_iterator& rhs)const
        {return current==rhs.current;}
        bool operator!=(const const_iterator & rhs)const
        {return current!=rhs.current;}
    };
    class iterator:public const_iterator
    {
    protected:
        iterator(Node *p):const_iterator(p){}
        friend class List<T>;
    public:
        iterator(){}
        T& operator*(){return retrieve();}
        const T& operator*()const{return const_iterator::operator *();}
        iterator& operator++()
        {
            current=current->next;
            return *this;
        }
        iterator operator ++(int)
        {
            iterator old=*this;
            ++(*this);
            return old;
        }
        iterator & operator--()
        {
            current=current->prev;
            return *this;
        }
        iterator operator--(int)
        {
            iterator old=*this;
            --(*this);
            return old;
        }
    };
    List(){Init();}
    List(const List<T> &l){Inti();operator=(l);}
    ~List(){Clear();delete head;delete tail;}
    const List& operator=(const List& l);
    int Size()const{return size;}
    bool Empty()const{return size==0;}
    void Clear(){while(!Empty())Pop_front();}
    iterator Erase(iterator itr);
    iterator Insert(iterator,const T& item);
    iterator Begin(){return iterator(head->next);}
    const_iterator Begin()const{return iterator(head->next);}
    iterator End(){return iterator(tail);}
    const_iterator End()const{return iterator(tail);}
    T& Front(){return *Begin();}
    const T& Front()const{return *Begin();}
    T& Back(){return *--End();}
    const T& Back()const{return *--End();}
    void Push_front(const T& item){Insert(Begin(),item);}
    void Push_back(const T& item){Insert(End(),item);}
    void Pop_front(){Erase(Begin());}
    void Pop_back(){Erase(--End());}

};


template<class T>
const List<T>& List<T>::operator =(const List<T>& l)
{
    Clear();
    for(const_iterator itr=l.Begin();itr!=l.End();++i)
        Push_back(*itr);
    return *this;
}


template<class T>
List<T>::iterator List<T>::Erase(iterator itr)
{
    Node*p=itr.current;
    iterator re(p->next);
    p->prev->next=p->next;
    p->next->prev=p->prev;
    delete p;
    size--;
    return re;
}
template<class T>
List<T>::iterator List<T>::Insert(iterator itr,const T& item)
{
    Node *p=itr.current;
    size++;
    p->prev->next=new Node(item,p->prev,p);
    p->prev=p->prev->next;
    return iterator(p->prev);
}

template<class T>
class Stack
{
    List<T>stackL;
public:
    Stack(){}
    ~Stack(){}
    int Size()const{return stackL.Size();}
    int Empty()const{return stackL.Empty();}
    const T& Top()const{return stackL.Back();}
    T Pop(){T item=stackL.Back();stackL.Pop_back();return item;}
    void Push(const T& item) {stackL.Push_back(item);}
    void Clear(){stackL.Clear();}
};
struct MathOperator
{
    char op;
    int ipre,spre;
    explicit MathOperator(char ch='+');
    bool operator>=(MathOperator optr)const{return (spre>=optr.ipre);}
};
MathOperator::MathOperator(char ch)
{
    op=ch;
    switch(op)
    {
        case'+':
        case'-':ipre=1;spre=1;break;
        case'/':
        case'*':ipre=2;spre=2;break;
        case'(':ipre=3;spre=-1;break;
        case')':ipre=0;spre=0;break;
    }
}