用类模板编的链栈，帮debug一下。^3Q^
/*-----------------------------------------
实现连续栈Stack
-----------------------------------------*/

template <typename Type> struct StackNode {
Type data; //结点数据
StackNode <Type> *link; //结点链指针
StackNode ( Type d, StackNode <Type> *l=NULL ) : data (d), link (l) { }
};
template <typename Type> class Stack {
public:
Stack ( ) : top ( NULL ) { }
~Stack ( );
Stack (const Stack &original);

void push ( const Type & item);
Type pop ( );
Type top ( );
void clearStack ( );
int isEmpty ( ) const
{ return top == NULL; }
private:
StackNode <Type> *top; //栈顶指针
};

template <typename Type>
Stack <Type> ::Stack()
{
top=NULL;
}

template <typename Type>
Stack <Type> ::~Stack()
{

StackNode <Type> * currPtr=myTop,nextPtr;
while(currPtr!=NULL)
{
nextPtr=currPtr-> next;
delete currPtr;
currPtr=nextPtr;
}
}

template <typename Type>
Stack <Type> ::Stack (const Stack &original)
{
Top=new Stack <Type> ::StackNode(original.top());
Stack <Type> ::StackNode lastPtr=myTop,
origPtr=original.myTop()-> next;
while(origPtr!=NULL)
{
lastPtr-> next=orgPtr;
lastPtr=lastPtr-> next;
origPtr=origPtr-> next;
}

}

template <typename Type>
void Stack <Type> :: push ( const Type & item);
{
top=new Stack::StackNode(item,top);
}

template <typename Type>
Type Stack <Type> ::pop()
{
if(!isEmpty())
{
Stack::StackNode * ptr=Top;
Top=Top-> next;
return *ptr;
delete ptr;
}
else cout < < "***Stack is empty--can 't remove a value. " < <endl;
}

template <typename Type>
Type Stack <Type> ::top()
{
if(!isEmpty())

return *top;
else
cout < < "***The stack is empty.*** " < <endl;
}

template <typename Type>
void Stack <Type> clearStack()
{

Stack::StackNode *currPtr=top;
Stack::StackNode *lastPtr;

while(lastPtr!=NULL)
{
lastPtr=currPtr-> next;
delete currPtr;
currPtr=lastPtr;

}
}

template <typename Type>
int Stack <Type> ::isEmpty ( ) const
{ return top == NULL; }

[解决办法]
语法问题不少

------------
template <typename Type> struct StackNode {
Type data;
StackNode <Type> *link;
StackNode ( Type d, StackNode <Type> *l=NULL ) : data (d), link (l) { }
};
template <typename Type> class Stack {
public:
Stack ();
//Stack ( ) : top ( NULL ) { } //下面也有定义？
~Stack ( );
Stack (const Stack &original);

void push ( const Type & item);
Type pop ( );
Type top ( );
void clearStack ( );
int isEmpty ( ) const
{ return top == NULL; }
private:
StackNode <Type> * ptop; //和函数同名？
};

template <typename Type>
Stack <Type> ::Stack()
{
ptop=NULL;
}

template <typename Type>
Stack <Type> ::~Stack()
{

StackNode <Type> * currPtr=myTop,nextPtr;
while(currPtr!=NULL)
{
nextPtr=currPtr-> next;
delete currPtr;
currPtr=nextPtr;
}
}

template <typename Type>
Stack <Type> ::Stack (const Stack &original)
{
Top=new Stack <Type> ::StackNode(original.top());
Stack <Type> ::StackNode lastPtr=myTop,
origPtr=original.myTop()-> next;
while(origPtr!=NULL)
{
lastPtr-> next=orgPtr;
lastPtr=lastPtr-> next;
origPtr=origPtr-> next;
}

}

template <typename Type>
void Stack <Type> :: push ( const Type & item)//分号？
{
top=new Stack::StackNode(item,top);
}

template <typename Type>
Type Stack <Type> ::pop()
{
if(!isEmpty())
{
Stack::StackNode * ptr=Top;
Top=Top-> next;
return *ptr;
delete ptr;
}
else cout < < "***Stack is empty--can 't remove a value. " < <endl;
}

template <typename Type>
Type Stack <Type> ::top()
{
if(!isEmpty())
return *top;
else
cout < < "***The stack is empty.*** " < <endl;
}

template <typename Type>
void Stack <Type> ::clearStack()//作用域解析符
{

Stack::StackNode *currPtr=top;
Stack::StackNode *lastPtr;

while(lastPtr!=NULL)
{
lastPtr=currPtr-> next;
delete currPtr;
currPtr=lastPtr;

}
}

// template <typename Type> //已经定义
// int Stack <Type> ::isEmpty ( ) const
// { return top == NULL; }