栈程序中出现的问题

//  array-based stack: definition and implementation for some methods
  
#include <iostream>
#include "myStack.h"
  
using namespace std;
  
template <class T>      
class arrStack : public Stack<T> {      
private:                                 // 栈的顺序存储
    int        mSize;                        // 栈中最多可存放的元素个数
    T         *st;                          // 存放栈元素的数组   
    int        top;                        // 栈顶位置，应小于mSize  
public:                                  // 栈的运算的顺序实现
    arrStack(int size);                    // 创建一个给定长度（size）的顺序栈的实例
    arrStack();                            // 创建一个顺序栈的实例
    ~arrStack();                        // 析构函数        
    void clear();                        // 清空栈内容
    bool push(const T item);                // 入栈操作的顺序实现     
    bool pop(T & item);                    // 出栈的顺序实现   
    bool getTop(T & item);                // 返回栈顶内容，但不弹出
    bool isEmpty();                        // 判断栈是否为空
    bool isFull();                        // 判断栈是否为满
};
template <class T>
arrStack<T>::arrStack(int size)
{
    st = new T [size];
    mSize = size;
    cout << "创建栈成功" << endl;
}
template <class T>
arrStack<T>::arrStack()
{
    top=-1 ;
}
template <class T>
arrStack<T>::~arrStack()
{
    delete st;
    cout << "删除栈成功" << endl;
}
template <class T>
void arrStack<T>::clear()
{
    top = -1;
}
template <class T>
bool  arrStack<T>::push(const T item)
{
    if (isFull()){ cout << "栈已满，无法输入数据" << endl; return 0; }
    else
    {
        top++;
        st[top] = item;
        return 1;
    }
}
template <class T>
bool arrStack<T>::pop(T & item)
{
    if (isEmpty()){ cout << "栈为空，无法实现弹栈" << endl; return 0; }
    else
    {
        item =st[top];
        top--;
        return 1;
    }
}
template <class T>
bool arrStack<T>::getTop(T & item)
{
    if (isEmpty()){ cout << "栈为空，无法实现该功能" << endl; return 0; }
    else
    {
        item =st[top];
        cout <<item;
        return 1;
    }
}
template <class T>
bool arrStack<T>::isEmpty()
{
    if (top == -1){ return 1; }
    else{ return 0; }
}
template <class T>
bool arrStack<T>::isFull()
{
    if (top > mSize-1 ){ return 1; }
    else { return 0; }
}

// abstract data type for stack
   
template <class T>                     // 栈的元素类型为 T
class Stack {  
public:                             // 栈的运算集
    void clear();                       // 变为空栈
       bool push(const T item);         // item入栈，成功则返回真，否则返回假
     bool pop(T* item);                // 返回栈顶内容并弹出，成功返回真，否则返回假,
     bool getTop(T* item);              // 返回栈顶内容但不弹出成功返回真，否则返回假,
       bool isEmpty();                    // 若栈已空返回真
       bool isFull();                    // 若栈已满返回真
};

//  array-based stack: definition and implementation for some methods
  
#include <iostream>
#include "myStack.h"
  
using namespace std;
  
template <class T>      
class arrStack : public Stack<T> {      
private:                                 // 栈的顺序存储
    int        mSize;                        // 栈中最多可存放的元素个数
    T         *st;                          // 存放栈元素的数组   
    int        top;                        // 栈顶位置，应小于mSize  
public:                                  // 栈的运算的顺序实现
    arrStack(int size);                    // 创建一个给定长度（size）的顺序栈的实例
    arrStack();                            // 创建一个顺序栈的实例
    ~arrStack();                        // 析构函数        
    void clear();                        // 清空栈内容
    bool push(const T item);                // 入栈操作的顺序实现     
    bool pop(T & item);                    // 出栈的顺序实现   
    bool getTop(T & item);                // 返回栈顶内容，但不弹出
    bool isEmpty();                        // 判断栈是否为空
    bool isFull();                        // 判断栈是否为满
};
template <class T>
arrStack<T>::arrStack(int size)
{
    st = new T [size];
    mSize = size;
    cout << "创建栈成功" << endl;
}
template <class T>
arrStack<T>::arrStack()
{
    top=-1 ;
}
template <class T>
arrStack<T>::~arrStack()
{
    delete st;
    cout << "删除栈成功" << endl;
}
template <class T>
void arrStack<T>::clear()
{
    top = -1;
}
template <class T>
bool  arrStack<T>::push(const T item)
{
    if (isFull()){ cout << "栈已满，无法输入数据" << endl; return 0; }
    else
    {
        top++;
        st[top] = item;
        return 1;
    }
}
template <class T>
bool arrStack<T>::pop(T & item)
{
    if (isEmpty()){ cout << "栈为空，无法实现弹栈" << endl; return 0; }
    else
    {
        item =st[top];
        top--;
        return 1;
    }
}
template <class T>
bool arrStack<T>::getTop(T & item)
{
    if (isEmpty()){ cout << "栈为空，无法实现该功能" << endl; return 0; }
    else
    {
        item =st[top];
        cout <<item;
        return 1;
    }
}
template <class T>
bool arrStack<T>::isEmpty()
{
    if (top == -1){ return 1; }
    else{ return 0; }
}
template <class T>
bool arrStack<T>::isFull()
{
    if (top > mSize-1 ){ return 1; }
    else { return 0; }
}

C/C++ code
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include <cstdlib>   
#include <iostream>   
   
#include "arrStack.h"     
   
using namespace std;   
   
long factorial(long n);   
   
int main(int argc, char *argv[])   
{
    long p=0;
    arrStack<long >  stack(5);
    stack.push(1);
    stack.push(2);
    stack.push(3);
    stack.push(4);
    stack.push(5);
    stack.pop(p);
    cout << p;
    stack.pop(p);
    cout << p;
    stack.pop(p);
    cout << p;
    stack.pop(p);
    cout << p;
    stack.pop(p);
    cout << p;
    cout << endl;
    factorial(2);
    return 0;

 
     

 

 

 

 

 

 

 

 

 

 
}      
// 求阶乘，用顺序栈实现  
long factorial(long n)
{
    arrStack< long >  stack(n);
    long m, x, z, l;
    for (long   i = n; i >0; i--)
    {
        stack.push(n);
        n--;
    }
    while (stack.isEmpty())
    {

 
        stack.getTop(m);
        stack.pop(x);
        stack.getTop(z);
        stack.pop(x);
        l = m*z;
    }
    return l;
}