中缀表达式计算

今天，秀华要做中缀表达式，在公司简单地跟她说了一下思路，没怎么细想。晚上回到家，想拿这个进行练笔，看看现在自己的水平怎么样了。

没想到折腾了半天才弄出来，水平真的菜了，唉。。。

1. // Expression.hxx
2. 
   
3. #ifndef _Expression_HeaderFile
4. #define _Expression_HeaderFile
5. 
   
6. 
   
7. #include <string>
8. #include <stack>
9. 
   
10. 
    
11. class Expression {
12. 
    
13. private:
14.     std::string        m_sValue;
15. 
    
16.     std::stack<char>   m_staOperators;
17.     std::stack<double> m_staOperands;
18. 
    
19. public:
20.     //! Construction
21.     Expression(const std::string &sExp);
22. 
    
23. public:
24.     //! Expression string
25.     const std::string &toString() const { return m_sValue; }
26. 
    
27.     //! go computation
28.     double compute();
29. 
    
30. private:
31.     //! the PRI of cOpt
32.     int getPRI(const char cOpt) const;
33. 
    
34.     //! pop two operands from m_staOperands, and compute the expression which
35.     //   algorithm have been defined by m_staOperators.top()
36.     void computeTwoOperands();
37. 
    
38. };
39. 
    
40. #endif // _Expression_HeaderFile
41. 
    

1. // Expression.cxx
2. 
   
3. #include "Expression.hxx"
4. #include <sstream>
5. 
   
6. 
   
7. /******************************************************************************/
8. Expression::Expression(const std::string &sExp)
9.     : m_sValue(sExp)
10. {
11. }
12. 
    
13. /******************************************************************************/
14. int
15. Expression::getPRI(const char cOpt) const {
16. 
    
17.     switch (cOpt) {
18.         case '$':   return 0;
19.         case '*':
20.         case '/':   return 1;
21.         case '+':
22.         case '-':   return 2;
23.         case ')':   return 3;
24.         case '(':   return 4;
25.         case ']':   return 5;
26.         case '[':   return 6;
27.         case '}':   return 7;
28.         case '{':   return 8;
29.     }
30. 
    
31.     return -1;
32. 
    
33. }
34. 
    
35. /******************************************************************************/
36. double
37. Expression::compute() {
38. 
    
39.     std::istringstream iss(m_sValue);
40. 
    
41.     char   cOpt;
42.     double rOperand;
43. 
    
44.     iss >> cOpt;
45. 
    
46.     while (!iss.eof()) {
47. 
    
48.         switch (cOpt) {
49. 
    
50.             case '(':
51.             case '[':
52.             case '{':
53.                 m_staOperators.push(cOpt);
54.             break;
55. 
    
56.             case ')':
57.             case ']':
58.             case '}':
59.                 while (!m_staOperators.empty() && getPRI(cOpt) >= getPRI(m_staOperators.top()))
60.                     computeTwoOperands();
61. 
    
62.                 m_staOperators.pop();
63.             break;
64. 
    
65.             case '*':
66.             case '/':
67.             case '+':
68.             case '-':
69.                 if (!m_staOperators.empty() && getPRI(cOpt) >= getPRI(m_staOperators.top()))
70.                     computeTwoOperands();
71. 
    
72.                 }
73. 
    
74.                 m_staOperators.push(cOpt);
75.             break;
76. 
    
77.             default:
78.                 iss.putback(cOpt);
79.                 iss >> rOperand;
80. 
    
81.                 m_staOperands.push(rOperand);
82.             break;
83. 
    
84.         }
85. 
    
86.         iss >> cOpt;
87. 
    
88.     }
89. 
    
90.     while (!m_staOperators.empty())
91.         computeTwoOperands();
92. 
    
93.     if (m_staOperands.size() == 1)
94.         return m_staOperands.top();
95. 
    
96.     return 0;
97. 
    
98. }
99. 
    
100. /******************************************************************************/
101. void
102. Expression::computeTwoOperands() {
103. 
     
104.     if (m_staOperands.size() >= 2 && !m_staOperators.empty()) {
105. 
     
106.         double opRight = 0.;
107. 
     
108.         opRight = m_staOperands.top();
109.         m_staOperands.pop();
110. 
     
111.         switch (m_staOperators.top()) {
112. 
     
113.             case '*':
114.                 m_staOperands.top() *= opRight;
115.                 m_staOperators.pop();
116.             break;
117. 
     
118.             case '/':
119.                 m_staOperands.top() /= opRight;
120.                 m_staOperators.pop();
121.             break;
122. 
     
123.             case '+':
124.                 m_staOperands.top() += opRight;
125.                 m_staOperators.pop();
126.             break;
127. 
     
128.             case '-':
129.                 m_staOperands.top() -= opRight;
130.                 m_staOperators.pop();
131.             break;
132. 
     
133.             default:
134.             break;
135. 
     
136.         }
137. 
     
138.     }
139. 
     
140. }
141. 
     

1. // Calculator.cxx : a console application for testing.
2. //
3. 
   
4. #ifndef _WIN32_WINNT                // Allow use of features specific to Windows XP or later.
5.     #define _WIN32_WINNT 0x0501     // Change this to the appropriate value to target other versions of Windows.
6. #endif
7. 
   
8. #include <stdio.h>  // for system
9. #include <iostream> // for std::cout
10. 
    
11. #include "Expression.hxx"
12. 
    
13. 
    
14. /******************************************************************************/
15. int
16. main(int argc, char* argv[]) {
17. 
    
18.     Expression exp("2*[5+3/(2-1)]*(4-1)");
19.     std::cout << exp.toString() << " = " << exp.compute() << std::endl;
20. 
    
21.     Expression exp2("2*3/(2-1)+5*(4-1)");
22.     std::cout << exp2.toString() << " = " << exp2.compute() << std::endl;
23. 
    
24.     system("pause");
25.     return 0;
26. 
    
27. }
28.