C++求解 可計算次方的計算機

ahjer

希望做出一計算機除了+-*/ 再加入^ 計算次方
例如 2+3*2^3 會正確地算出26
(次方優先判斷後*/再+-)

以下是上課練習+課本求解才弄出的基本四則運算計算機
可是要加上次方就GG了

1. #include <iostream>                  
   
2. #include <cstdlib>                    
   
3. #include <cctype>                     
   
4. #include <cstring>z
   
5. using std::cin;
   
6. using std::cout;
   
7. using std::endl;
   
8. 
   
9. void eatspaces(char* str);            // Function to eliminate blanks
   
10. double expr(char* str);               // Function evaluating an expression
    
11. double term(char* str, int& index);   // Function analyzing a term
    
12. double number(char* str, int& index); // Function to recognize a number
    
13. char* extract(char* str, int& index); // Function to extract a substring
    
14. const int MAX(80);                    // Maximum expression length,
    
15.                                       // including '\0'
    
16. int main()
    
17. {
    
18.    char buffer[MAX]={0};    // Input area for expression to be evaluated
    
19. 
    
20.    cout<<"我是計算機唷 出題目吧~"<<endl<<endl;
    
21. 
    
22.    for(;;)
    
23.    {
    
24.       cin.getline(buffer, sizeof buffer);   // Read an input line
    
25.       eatspaces(buffer);                    // Remove blanks from input
    
26. 
    
27.       if(!buffer[0])                        // Empty line ends calculator
    
28.          return 0;
    
29. 
    
30.       cout << "\t= " << expr(buffer)        // Output value of expression
    
31.            << endl << endl;
    
32.    }
    
33. }
    
34. 
    
35. 
    
36. // Function to eliminate spaces from a string
    
37. void eatspaces(char* str)
    
38. {
    
39.    int i(0);                              // 'Copy to' index to string
    
40.    int j(0);                              // 'Copy from' index to string
    
41. 
    
42.    while((*(str+i)=*(str+j++))!='\0')  // Loop while character
    
43.                                                // copied is not \0
    
44.       if(*(str+i) != ' ')                    // Increment i as long as
    
45.          i++;                                  // character is not a space
    
46.    return;
    
47. }
    
48. 
    
49. // Function to evaluate an arithmetic expression
    
50. double expr(char* str)
    
51. {
    
52.   double value(0.0);                   // Store result here
    
53.   int index(0);                        // Keeps track of current character position
    
54. 
    
55.   value = term(str, index);            // Get first term
    
56. 
    
57.   for(;;)                              // Indefinite loop, all exits inside
    
58.   {
    
59.     switch(*(str + index++))           // Choose action based on current character
    
60.     {
    
61.       case '\0':                       // We're at the end of the string
    
62.          return value;                 // so return what we have got
    
63. 
    
64.       case '+':                        // + found so add in the
    
65.          value += term(str, index);    // next term
    
66.          break;
    
67. 
    
68.       case '-':                        // - found so subtract
    
69.          value -= term(str, index);    // the next term
    
70.          break;
    
71. 
    
72.       default:                        
    
73.          cout<<"發生錯誤~!!!"<<endl;
    
74.          exit(1);
    
75.     }
    
76.   }
    
77. }
    
78. 
    
79. // Function to get the value of a term
    
80. double term(char* str, int& index)
    
81. {
    
82.   double value(0.0);                   // Somewhere to accumulate
    
83.                                        // the result
    
84. 
    
85.   value=number(str, index);          // Get the first number in the term
    
86. 
    
87.   // Loop as long as we have a good operator
    
88.   while(true)
    
89.   {
    
90. 
    
91.     if(*(str+index) == '*')          // If it's multiply,
    
92.       value *= number(str, ++index);   // multiply by next number
    
93. 
    
94.     else if(*(str+index) == '/')     // If it's divide,
    
95.       value /= number(str, ++index);   // divide by next number
    
96.     else
    
97.       break;
    
98.   }
    
99.   return value;                        // We've finished, so return what
    
100.                                        // we've got
     
101. }
     
102. 
     
103. // Function to recognize a number in a string
     
104. double number(char* str, int& index)
     
105. {
     
106.   double value(0.0);                   // Store the resulting value
     
107.   
     
108.   if((*(str + index) == '(') || (*(str + index) == '{'))            // Start of parentheses
     
109.   {
     
110.     char* psubstr=NULL;            // Pointer for substring
     
111.     psubstr = extract(str, ++index);   // Extract substring in brackets
     
112.     value = expr(psubstr);             // Get the value of the substring
     
113.     delete[]psubstr;                   // Clean up the free store
     
114.     return value;                      // Return substring value
     
115.   }
     
116. 
     
117.   // There must be at least one digit...
     
118.   if(!isdigit(*(str + index)))
     
119.   { // There's no digits so input is junk...
     
120.     cout<<"發生錯誤~!!!"<<endl;
     
121.     exit(1);
     
122.   }
     
123. 
     
124.   while(isdigit(*(str + index)))       // Loop accumulating leading digits
     
125.     value = 10*value + (*(str + index++) - '0');
     
126. 
     
127.                                        // Not a digit when we get to here
     
128.   if(*(str+index) != '.')            // so check for decimal point
     
129.     return value;                      // and if not, return value
     
130. 
     
131.   double factor(1.0);                  // Factor for decimal places
     
132.   while(isdigit(*(str + (++index))))   // Loop as long as we have digits
     
133.   {
     
134.     factor *= 0.1;                     // Decrease factor by factor of 10
     
135.     value = value + (*(str + index) - '0')*factor;   // Add decimal place
     
136.   }
     
137. 
     
138.   return value;                        // On loop exit we are done
     
139. }
     
140. 
     
141. // Function to extract a substring between parentheses
     
142. // (requires cstring)
     
143. char* extract(char* str, int& index)
     
144. {
     
145.   char buffer[MAX];                   // Temporary space for substring
     
146.   char* pstr=NULL;
     
147.   int numB(0);                // Pointer to new string for return
     
148.   int numL(0);                        // Count of left parentheses found
     
149.   int bufindex(index);                // Save starting value for index
     
150. 
     
151.   do
     
152.   {
     
153.     buffer[index - bufindex] = *(str + index);
     
154.     switch(buffer[index - bufindex])
     
155.     {
     
156.       case '}' :
     
157.         if(0==numB)   
     
158.         {
     
159.            buffer[index - bufindex] = '\0';  // Replace ')' with '\0'
     
160.           ++index;
     
161.           pstr = new char[index - bufindex];
     
162.           if(!pstr)
     
163.           {
     
164.             cout<<"阿阿阿 程式崩壞----!!!"<<endl;
     
165.             exit(1);
     
166.           }
     
167.           strcpy(pstr,buffer); // Copy substring to new memory
     
168.           return pstr;           
     
169.          }   
     
170.          else
     
171.           numB--;                      // Reduce count of '(' to be matched
     
172.           break;  
     
173.            
     
174.       case '{' :
     
175.            numB++;     
     
176.            break;
     
177. 
     
178.       case ')':
     
179.         if(0 == numL)
     
180.         {
     
181.           buffer[index - bufindex] = '\0';  // Replace ')' with '\0'
     
182.           ++index;
     
183.           pstr = new char[index - bufindex];
     
184.           if(!pstr)
     
185.           {
     
186.             cout<<"阿阿阿 程式崩壞----!!!"<<endl;
     
187.             exit(1);
     
188.           }
     
189.           strcpy(pstr,buffer); // Copy substring to new memory
     
190.           return pstr;                 // Return substring in new memory
     
191.         }
     
192.         else
     
193.           numL--;                      // Reduce count of '(' to be matched
     
194.           break;
     
195. 
     
196.       case '(':
     
197.         numL++;                        // Increase count of '(' to be
     
198.                                    // matched
     
199.         break;
     
200.       }
     
201.   } while(*(str + index++) != '\0'); // Loop - don't overrun end of string
     
202. 
     
203.   cout<<endl<<"=3="<<endl;
     
204.   exit(1);
     
205. }

複製代碼

...

瀏覽完整內容，請先 註冊 或 登入會員

建議你先將中序表示式先轉換成後(or前)序式後，再來做四則運算。
如此一來，你也可以定義你自己的運算子並且定義自訂運算子的優先順序。