？

#include <cstdlib>
#include <iostream>
using namespace std;
long factorial(long n);


// 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

template <class T> 	
class arrStack : public Stack<T> {      
private: 	                    	// 栈的顺序存储
	int		mSize;			// 栈中最多可存放的元素个数
	T 		*st;	  		// 存放栈元素的数组
public:  
         int		top;					// 栈顶位置，应小于mSize 
public:  						// 栈的运算的顺序实现
	arrStack(int size){ 				// 创建一个顺序栈的实例
		mSize = size;
		top = -1;
		st = new T[mSize];
	}
	arrStack(){
        top = -1;
    }
	~arrStack() {					// 析构函数
		delete [] st;
	}
	void clear() {					// 清空栈内容
		top = -1;
    }
	bool push(const T item) { 	   		// 入栈操作的顺序实现	
		if (top == mSize-1) {  			// 栈已满 
			cout << "栈满溢出" << endl;
			return false;
		}
		else {					// 新元素入栈并修改栈顶指针
			st[++top] = item;
			return true;
		}
	}
	bool pop(T* item) { 	        	                  	// 出栈的顺序实现
		if (top == -1) {			                       // 栈为空
			cout << "栈为空，不能出栈操作"<< endl; 
			return false;
		}
		else {
			*item = st[top--];	         // 返回栈顶元素并修改栈顶指针
			return true;
		}
	}
	bool getTop(T* item) {				     // 返回栈顶内容，但不弹出
		if (top == -1) {			         // 栈空
			cout << " 栈为空，不能出栈操作"<< endl; 
			return false;
		}
		else { 						
			*item = st[top];
			return true;
		}
    }
    bool isEmpty() { 
         return (top == -1);
    }
    bool isFull() { 
         return (top == mSize-1);
    }
};



int main(int argc, char *argv[])
{
    long x, m;
	cin >> x;
    cout << "the factioral of "
         << x 
         << "is " ;
	m = factorial(x);
	cout << m 
       <<endl;
    cin >> x;
}


/* recurive version
long factorial(long n)  {
	if (n <= 0) 
		return 1;
	return n * factorial(n-1);
}


// iterated version 
long factorial(long n) {
		long  m = 1;
		long  i ;
		if (n > 0)
			for ( i = 1;  i <= n;  i++ )
				m = m * i ;
		return m ;
}    

*/

// nonrevursive with stack
long factorial(long n) {
     arrStack<long> s(20);
	 long tmp;
     
	 long m = 1;
	 while (n > 0)                  	// 不满足递归出口      
		s.push(n--);				// 按递归规则把相应数据压栈
	 while (!s.isEmpty()) {			// 递归出口满足，开始进行返回处理
		s.pop(&tmp);
		m *= tmp;
     } 
	 return m ;
}