Stack.hpp

  1. #pragma once


  3. template

  4. class Stack{

  5. private:

  6. T* _array;

  7. size_t _capacity;

  8. int _topindex;

  9. public:

  10. Stack()          //构造函数

  11. :_array(0)

  12. , _capacity(0)

  13. , _topindex(-1)

  14. {}

  15. void Push(const T& x){                         //入栈操作

  16. if (_topindex + 1 == _capacity){

  17. _capacity = 2 * _capacity + 3;

  18. T* tmp = new T[_capacity];

  19. if (tmp == NULL){

  20. cout << "failed new" << endl;

  21. exit(-1);

  22. }

  23. memcpy(tmp, _array, sizeof(T) * (_topindex + 1));

  24. delete _array;

  25. _array = tmp;

  26. }

  27. _array[++_topindex] = x;

  28. }

  29. void Pop(){                                      //出栈

  30. if (_topindex > -1){

  31. //cout << _array[_topindex] << endl;

  32. _topindex--;

  33. }

  34. } 

  35. bool empty(){                  //清空

  36. return _topindex = -1;

  37. }

  38. const T& top(){                             //取栈顶元素

  39. //cout << _array[_topindex] << endl;

  40. return _array[_topindex];

  41. }

  42. };


  44. main.cpp

  45. #include

  46. #include

  47. #include"Stack.hpp"

  48. using namespace std;


  50. enum Type{

  51. ADD,

  52. SUB,

  53. MUL,

  54. DIV,

  55. OP_NUM,

  56. };


  58. struct Cell{

  59. Type _type;

  60. int num;

  61. };


  63. Cell RPNExp[] = {

  64. OP_NUM, 12,

  65. OP_NUM, 3,

  66. OP_NUM, 4,

  67. ADD, 1,

  68. MUL, 1,

  69. OP_NUM, 6,

  70. SUB, 1,

  71. OP_NUM, 8,

  72. OP_NUM, 2,

  73. DIV, 1,

  74. ADD, 1,

  75. };


  77. int main(){   

  78. Stack s2;    

  79. int i = 0;

  80. for (int i = 0; i < sizeof(RPNExp) / sizeof(RPNExp[0]);i++){  //取出元素

  81.     int left, right;             //两个操作数

  82. switch (RPNExp[i]._type){        //将栈中数据出栈

  83. case ADD:                         //如果是加号，取两个操作数

  84. left = s2.top();

  85. s2.Pop();

  86. right = s2.top();

  87. s2.Pop();

  88. s2.Push(left + right);         //新的值入栈

  89. break;

  90. case SUB:                       //如果是减号，取两个操作数

  91. left = s2.top();

  92. s2.Pop();

  93. right = s2.top();

  94. s2.Pop();

  95. s2.Push(right - left);

  96. break;

  97. case MUL:                         //如果是乘号，取两个操作数

  98. left = s2.top();

  99. s2.Pop();

  100. right = s2.top();

  101. s2.Pop();

  102. s2.Push(left * right);

  103. break;

  104. case DIV:                        //如果是除号，取两个操作数

  105. left = s2.top();

  106. s2.Pop();

  107. right = s2.top();

  108. s2.Pop();

  109. s2.Push(right / left);

  110. break;

  111. case OP_NUM:                     //如果数字，入栈

  112. s2.Push(RPNExp[i].num);

  113. break;

  114. default:

  115. return -1;

  116. }

  117. }

  118. cout << s2.top() << endl;

  119. return 0;

  120. }