这是本人的代码：
路径：E:\学习\数据结构\stack.h
/*堆栈ADT
ADT Stack{
数据：
0个或多个元素的线性序列(a0,a1,…,an-1),其最大允许长度为MaxStackSize。
运算：
Create():建立一个空栈。
Destroy():撤销一个栈。
IsEmpty():若栈为空，则返回true;否则返回false。
IsFull():若栈满，则返回true;否则返回false。
Top(x):在x中返回栈顶元。若操作成功，则返回true;否则返回false。
Push(x):在栈顶插入元素x(入栈)。若操作成功，则返回true;否则返回false。
Ppo():从栈顶中删除元素(出栈)。若操作成功，则返回true;否则返回false。
Clear():清除堆栈中全部元素。
}*/
#include<iostream>
using namespace std;
template <class T>
class stack
{
public:
virtual bool IsEmpty() const=0;
virtual bool IsFull() const=0;
virtual bool Top(T &x) const=0;
virtual bool Push(T x)=0;
virtual bool Pop()=0;
virtual void Clear()=0;
};
路径：E:\学习\数据结构\seqstack.h
#include “..\数据结构\stack.h”
template<class T>
class SeqStack:public Stack<T>
{
public:
SeqStack(int mSize);
~SeqStack() {delete []s;}
bool IsEmpty() const {return top == -1;}
bool IsFull() const {return top == maxTop; }
bool Top(T &x) const;
bool Push(T x);
bool Pop();
void Clear(){ top = -1; }
private:
int top;                   //栈顶指针
int maxTop;                //最大栈顶指针
T* s;
};
template<class T>
SeqStack<T>::SeqStack(int mSize)
{
maxTop=mSize-1;
s=new T[mSize];
top=-1;
}
template<class T>
bool SeqStack<T>::Top(T & x)  const
{
if(IsEmpty()){
cout<<“Empty”<<endl;
return false;
}
x=s[top];
return true;
}
template<class T>
bool SeqStack<T>::Push(T x)
{
if(IsFull()){               //溢出处理
cout<<“Overflow”<<endl;
return false;
}
s[top++]=x;
return true;
}
template <class T>
bool SeqStack<T>::Pop()
{
if(IsEmpty()){              //空栈处理
cout<<“Underflow”<<endl;
return false;
}
top–;
return true;
}
路径：E:\学习\数据结构\简单的后缀表达式计算器\calculate.h
#include “..\seqstack.h”
#include<math.h>
class Calculator
{
public:
Calculator(int maxSize){s(maxSize);};
void Run();                            //从输入流逐个读入字符，做相应的运算，输出结果
void Clear(){s.Clear();};
private:
SeqStack<double> s(maxSize);                    //声明存放操作数的栈对象
void PushOperand(double);              //操作数进栈
bool GetOperands(double &,double &);   //从栈中弹出2个操作数
void DoOperator(char);                 //根据操作符做相应的运算
};
void Calculator::PushOperand(double op)
{
s.Push(op);
}
bool Calculator::GetOperands(double &op1,double &op2)
{
if (!s.Top(op1)){
cerr<<“Missing operand!”<<endl;
return false;
}
s.Pop();
if(!s.Top(op2)){
cerr<<“Missing operand!”<<endl;
return false;
}
s.Pop();
return true;
}
void Calculator::DoOperator(char oper)
{
bool result;
double oper1,oper2;
result=GetOperands(ooper1,oper2);     //从栈中弹出2个操作数
if(result)
switch(oper)                      //根据操作符做相应的运算，先出栈的操作数oper1
{                                     //放在操作符的右边，后出栈的oper2放在左边
case “”+””: s.Push(oper2+oper1); break;
case “”-“”: s.Push(oper2-oper1); break;
case “”*””: s.Push(oper2*oper1); break;
case “”/””: if(fabs(oper1)<1e-6){             //假如分母为0，则做出错处理
cerr<<“Divide by 0!”<<endl;
Clear();
}
else s.Push(oper2/oper1);break;
}
else Clear();
}
void Calculator::Run()
{
char c;double newop;
while (cin>>c,c!=””#””){               //从输入流试读入一个字符，遇结束符结束
switch(c){
case “”+””:
case “”-“”:
case “”*””:
case “”/””:
case “”^””:DoOperator(c);break;  //是操作符则进行相应的计算
default: cin.putback(c);       //如不是操作符，则将试读入的字符放回输入流
cin>>newop;
PushOperand(newop);break;      //操作数进栈
}
}
if(s.Top(newop)) cout<<newop<<endl;    //取出栈顶元素
}
#include “calculator.h”
const int SIZE=20;
int main()
{
Calculator Cal(SIZE);
Cal.Run();
return 0;
}
ERROR:
E:\学习\数据结构\简单的后缀表达式计算器\..\seqstack.h|3|error: expected template-name before “”<“” token|
E:\学习\数据结构\简单的后缀表达式计算器\..\seqstack.h|3|error: expected “”{“” before “”<“” token|
E:\学习\数据结构\简单的后缀表达式计算器\..\seqstack.h|3|error: expected unqualified-id before “”<“” token|
E:\学习\数据结构\简单的后缀表达式计算器\..\seqstack.h|20|error: invalid use of incomplete type “”class SeqStack<T>””|
E:\学习\数据结构\简单的后缀表达式计算器\..\seqstack.h|3|error: declaration of “”class SeqStack<T>””|
还有好多ERROR，但主要就是第一个不知道怎么处理，看了几个帖子，都看不懂问题在哪。