汉诺塔游戏流传已久，它主要存在着两种限制：1、先进后出；2、上小下大，而“先进后出”或者“LIFO”（后进先出，Last In First Out）就是汉诺塔移动的法则。

下面是用C++写的栈stack，经过一些简单测试可以实现栈的一些简单操作，测试环境为MS VS8。

1. #include <tchar.h>
3. /*
4. 数据结构——栈
5. 栈要遵守“后进先出的规则”
6. */
9. template <class ElemType>
10. class stack{
11. private:
12.     ElemType* stk_;
13.     int size_;                      //栈的大小
14.     int length_;                    //栈中元素的个数
15. public:
16.     stack(int initsize);
17.     ~stack();
18.     void InitStack(int initsize);    //初始化栈
19.     void DestroyStack();             //销毁栈
20.     int GetLength();                 //取得栈中元素个数
21.     ElemType* GetTop();              //取得顶点元素
22.     bool StackEmpty();               //栈是否空
23.     bool StackFull();                //栈是否满
24.     bool push(ElemType* aItem);      //添加元素，
25.     ElemType* pop();                 //删除元素
26.     ElemType* Get(int index);        //取得index位置的元素
27. };
31. template<class ElemType>
32. void stack<ElemType>::InitStack(int initsize)
33. {
34.     stk_ = new ElemType[initsize];
35.     size_ = initsize;
36.     length_ = 0;
37. }
39. template<class ElemType>
40. void stack<ElemType>::DestroyStack()
41. {
42.     delete[] stk_;
43.     length_ = 0;
44. }
46. template<class ElemType>
47. stack<ElemType>::stack(int initsize)
48. {
49.     InitStack(initsize);
50. }
52. template<class ElemType>
53. stack<ElemType>::~stack()
54. {
55.     DestroyStack();
56. }
58. template<class ElemType>
59. int stack<ElemType>::GetLength()
60. {
61.     return length_;
62. }
64. template<class ElemType>
65. ElemType* stack<ElemType>::GetTop()
66. {
67.     return &stk_[length_];
68. }
70. template<class ElemType>
71. ElemType* stack<ElemType>::Get(int index)
72. {
73.     if(index < length_)
74.     {
75.         return &stk_[index];
76.     }
77.     else return NULL;
78. }
80. template<class ElemType>
81. bool stack<ElemType>::StackEmpty()
82. {
83.     return(length_ == 0);
84. }
86. template<class ElemType>
87. bool stack<ElemType>::StackFull()
88. {
89.     return(length_ == size_);
90. }
92. template<class ElemType>
93. bool stack<ElemType>::push(ElemType* aItem)
94. {
95.     if(!StackFull())
96.     {
97.         stk_[length_] = *aItem;
98.         length_ ++;
99.         return true;
100.     }
101.     else return false;
102. }
104. template<class ElemType>
105. ElemType* stack<ElemType>::pop()  
106. {
107.     ElemType* p = NULL;
108.     if(!StackEmpty())
109.     {
110.         length_ –;
111.         p = &stk_[length_];
112.     }
113.     return p;
114. }

测试代码如下：

1. stack<int>* stk = new stack<int>(10);
2. for(int i = 0; i < 4; i++)
3. {
4.     if (stk->push(&i))
5.         printf(“%d has been pushed./n”,i);
6.     else
7.         printf(“%d pushed failed!/n”,i);
8. }
9. printf(“%d has get top./n”,stk->GetTop());
10. for(int i = 0; i < 4; i++)
11. {
12.     printf(“%d has been getted./n”,*stk->Get(i));
13. }
14. for(int i = 0; i < 3; i++)
15. {
16.     printf(“%d has been pop./n”,*stk->pop());
17. }
18. for(int i = 0; i < 4; i++)
19. {
20.     int* a = stk->Get(i);
21.     if (a != NULL)
22.         printf(“%d has been getted./n”,*a);
23.     else
24.         printf(“No%d. Item is not exist!/n”,i);
25. }
26. delete stk;