简单计算器的实现

川长思鸟来 2022-08-02 09:34 346阅读 0赞

计算器

问题描述： 输入一个简单四则运算表达式字符串，计算该表达式的值

注：
1、表达式只含 +, -, *, /, (, ), 四则运算符
2、表达式数值只包含整数(0-9)，每个操作数可以是多位，且不会出现0作为除数的情况
3、要考虑加减乘除按通常四则运算规定的计算优先级
4、除法用整数除法，即仅保留除法运算结果的整数部分。比如80/3=26。输入表达式保证无0作为除数情况发生
5、输入字符串一定是符合题意合法的表达式，其中只包括数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出情况

要求实现函数：
int calculate(int len,char *expStr)

【输入】 int len: 字符串长度； char *expStr: 表达式字符串；
【输出】 无
【返回】 计算结果
• 示例
1） 输入：char *expStr = “-3*(-200)-(-3*(-5-2*10)/(4+3-17)*9)” 

  1.   函数返回：663

2） 输入：char *expStr = “8/3*3” 

  1.   函数返回：6  
  10. #include "stdafx.h"
  11. #include<vector>
  12. #include<deque>
  13. #include<iostream>
  14. using namespace std;
  17. char*vec2char(vector<char>vec, char*str)
  18. {
  19.     char*s = str;
  20.     vector<char>::iterator it;
  21.     it = vec.begin();
  22.     while (it != vec.end())
  23.         *(s++) = *(it++);
  24.     *s = '\0';
  25.     return str;
  26. }
  28. //计算不带括号的表达式的值
  29. int calculate_without_bracket(vector<char>&substr)
  30. {
  31.     vector<char>::iterator it, it1, it2, iter;
  32.     char*str = new char[100];
  33.     it = substr.begin();
  34.     while (it != substr.end())
  35.     {
  36.         deque<int>bb;
  37.         deque<int>::iterator p;
  38.         int aa;
  39.         //因为每次去括号时，都会对多个“-”
  40.         //号进行合并，这里不会出现多于两个“-”相连的情况
  41.         if (*substr.begin() == '-')
  42.         {
  43.             if (*(substr.begin() + 1) == '-')
  44.             {
  45.                 substr.erase(substr.begin(), substr.begin() + 2);
  46.                 it = substr.begin();
  47.             }
  48.         }
  49.         if (*it == '*' || *it == '/')
  50.         {
  51.             bool flag1 = false;
  52.             bool flag2 = false;
  53.             int f1 = 0, f2 = 0;
  54.             it1 = it - 1;
  56.             int gg = 0;
  57.             while (*it1 - '0' >= 0 && *it1 - '0' <= 9 && it1 - substr.begin() >= 0)
  58.             {
  59.                 gg++;
  60.                 bb.push_front(*it1 - '0');
  61.                 if (it1 == substr.begin())
  62.                     break;
  63.                 it1--;
  64.             }
  65.             if (it1 != substr.begin())
  66.             {
  67.                 if (*it1 == '-')
  68.                 {
  69.                     if (*(it1 - 1) == '-')
  70.                         if (it1 - 1 == substr.begin())
  71.                         {
  72.                             substr.erase(substr.begin(), substr.begin() + 2);
  73.                             it = substr.begin() + gg;
  74.                             it1 = substr.begin();
  75.                         }
  76.                         else
  77.                         {
  78.                             it1 = it1 - 2;
  79.                             substr.erase(it1 + 1, it1 + 3);
  80.                             substr.insert(it1 + 1, '+');
  81.                             it1 = it1 + 2;
  82.                             it = it1 + gg;
  83.                         }
  84.                     else if (*(it1 - 1) == '+')//这一次的乘除运算之前不可能出现别的“*”或“/”
  85.                     {
  86.                         it1 = it1 - 2;
  87.                         substr.erase(it1 + 1, it1 + 3);
  88.                         substr.insert(it1 + 1, '-');
  89.                         it1 = it1 + 2;
  90.                         it = it1 + gg;
  91.                     }
  92.                     else
  93.                         it1++;
  94.                 }
  96.             }
  97.             else if (it1 == substr.begin() && *it1 == '-')
  98.                 it1++;
  99.             it2 = it + 1;
  100.             if (*it2 == '-')
  101.             {
  102.                 flag1 = true;
  103.                 it2++;
  104.             }
  105.             p = bb.begin();
  106.             while (p != bb.end())
  107.             {
  108.                 f1 = *p + 10 * f1;
  109.                 ++p;
  110.             }
  111.             while (it2 != substr.end() && *it2 - '0' >= 0 && *it2 - '0' <= 9)
  112.             {
  113.                 f2 = 10 * f2 + (*it2 - '0');
  114.                 it2++;
  115.             }
  116.             if (*it == '*')
  117.                 aa = f1*f2;
  118.             else
  119.                 aa = f1 / f2;
  120.             if (flag1)
  121.                 aa = -aa;
  122.             char*ss = new char[100];
  123.             _itoa(aa, ss, 10);
  124.             if (it1 == substr.begin())
  125.             {
  126.                 int c = 0;
  127.                 substr.erase(it1, it2);
  128.                 while (*ss != '\0')
  129.                 {
  130.                     substr.insert(substr.begin() + c, *ss);
  131.                     ++ss;
  132.                     ++c;
  133.                 }
  134.                 it = substr.begin();
  135.             }
  136.             else
  137.             {
  138.                 int c = 0;
  139.                 iter = it1 - 1;
  140.                 substr.erase(it1, it2);
  141.                 while (*ss != '\0')
  142.                 {
  143.                     substr.insert(iter + 1 + c, *ss);
  144.                     ++ss;
  145.                     ++c;
  146.                 }
  147.                 //substr.insert(iter + 1, aa+'0');
  148.                 it = iter + 1;
  149.             }
  150.         }
  151.         else
  152.         {
  154.             it++;
  155.         }
  156.         //if (substr.size() == 1)
  157.         // return (*substr.begin() - '0');
  158.     }
  159.     it = substr.begin();
  160.     while (it != substr.end())
  161.     {
  163.         deque<int>bb;
  164.         deque<int>::iterator p;
  165.         int aa;
  166.         if (*substr.begin() == '-')
  167.         {
  168.             if (*(substr.begin() + 1) == '-')
  169.             {
  170.                 substr.erase(substr.begin(), substr.begin() + 2);
  172.             }
  173.             else
  174.             {
  175.                 bool flag2 = false;
  176.                 int f1 = 0, f2 = 0;
  177.                 it1 = substr.begin() + 1;
  179.                 while (*it1 - '0' >= 0 && *it1 - '0' <= 9)
  180.                 {
  181.                     bb.push_back(*it1 - '0');
  182.                     it1++;
  183.                     if (it1 == substr.end())
  184.                     {
  185.                         char*src = new char[100];
  186.                         return atoi(vec2char(substr, src));
  187.                     }
  188.                 }
  190.                 p = bb.begin();
  191.                 while (p != bb.end())
  192.                 {
  193.                     f1 = *p + 10 * f1;
  194.                     ++p;
  195.                 }
  196.                 it = it1;
  197.                 it2 = it + 1;
  198.                 if (*it2 == '-')//因为每次去括号时，都会对多个“-”
  199.                     //号进行合并，这里不会出现多于两个“-”相连的情况
  200.                 {
  201.                     it2++;
  202.                     flag2 = true;
  203.                 }
  204.                 while (it2 != substr.end() && *it2 - '0' >= 0 && *it2 - '0' <= 9)
  205.                 {
  206.                     f2 = 10 * f2 + (*it2 - '0');
  207.                     it2++;
  208.                 }
  209.                 if (*it == '+')
  210.                     if (flag2)
  211.                         aa = -f1 - f2;
  212.                     else
  213.                         aa = -f1 + f2;
  214.                 else
  215.                     if (flag2)
  216.                         aa = -f1 + f2;
  217.                     else
  218.                         aa = -f1 - f2;
  219.                 char*ss = new char[100];
  220.                 _itoa(aa, ss, 10);
  221.                 int c = 0;
  222.                 substr.erase(substr.begin(), it2);
  223.                 while (*ss != '\0')
  224.                 {
  225.                     substr.insert(substr.begin() + c, *ss);
  226.                     ++ss;
  227.                     ++c;
  228.                 }
  229.                 //substr.insert(substr.begin(), aa + '0');
  230.                 it = substr.begin();
  232.             }
  233.         }
  234.         else if
  235.             //因为每次都是从左到右一次只计算两个数，除了第一个符号是“-”外，另一种
  236.             //情况下第一个操作数一定是正数，只需考虑第二个操作数的符号
  237.             (*it == '+' || *it == '-')
  238.         {
  239.             bool flag1 = false;
  240.             int f1 = 0, f2 = 0;
  241.             it1 = it - 1;
  242.             it2 = it + 1;
  243.             if (*it2 == '-')
  244.             {
  245.                 flag1 = true;
  246.                 it2++;
  247.             }
  248.             while (*it1 - '0' >= 0 && *it1 - '0' <= 9 && it1 - substr.begin() >= 0)
  249.             {
  250.                 bb.push_front(*it1 - '0');
  251.                 if (it1 == substr.begin())
  252.                     break;
  253.                 it1--;
  254.             }
  255.             if (it1 != substr.begin())
  256.                 it1++;
  257.             p = bb.begin();
  258.             while (p != bb.end())
  259.             {
  260.                 f1 = *p + 10 * f1;
  261.                 ++p;
  262.             }
  263.             while (it2 != substr.end() && *it2 - '0' >= 0 && *it2 - '0' <= 9)
  264.             {
  265.                 f2 = 10 * f2 + (*it2 - '0');
  266.                 it2++;
  267.             }
  268.             if (*it == '+')
  269.                 if (flag1)
  270.                     aa = f1 - f2;
  271.                 else
  272.                     aa = f1 + f2;
  273.             else
  274.                 if (flag1)
  275.                     aa = f1 + f2;
  276.                 else
  277.                     aa = f1 - f2;
  278.             char*ss = new char[100];
  279.             _itoa(aa, ss, 10);
  280.             if (it1 == substr.begin())
  281.             {
  282.                 int c = 0;
  283.                 substr.erase(it1, it2);
  284.                 while (*ss != '\0')
  285.                 {
  286.                     substr.insert(substr.begin() + c, *ss);
  287.                     ++ss;
  288.                     ++c;
  289.                 }
  290.                 //substr.insert(substr.begin(), aa + '0');
  291.                 it = substr.begin();
  292.             }
  293.             else
  294.             {
  295.                 //iter = it - 2;
  296.                 //substr.erase(it - 1, it + 2);
  297.                 //substr.insert(iter + 1, aa + '0');
  298.                 //it = iter + 1;
  299.                 int c = 0;
  300.                 iter = it1 - 1;
  301.                 substr.erase(it1, it2);
  302.                 while (*ss != '\0')
  303.                 {
  304.                     substr.insert(iter + 1 + c, *ss);
  305.                     ++ss;
  306.                     ++c;
  307.                 }
  308.                 it = iter + 1;
  309.             }
  311.         }
  312.         else
  313.         {
  314.             it++;
  315.         }
  316.     }
  318.     return atoi(vec2char(substr, str));
  319. }
  325. //去括号，每次找到第一对连续匹配的括号，然后用calculate_without_bracket函数
  326. //计算括号里的表达式的值，计算后的结果插入原表达式，返回true。
  327. //如果原表达式没有括号，返回false
  328. bool erase_bracket(vector<char>&str)
  329. {
  330.     int size = str.size();
  331.     bool flag = false;
  332.     int k = 0;
  333.     int m, n;
  334.     vector<char>::iterator it, it1, it2;
  335.     it = str.begin();
  336.     while (k < size)
  337.     {
  338.         if (str[k] == '(')
  339.         {
  340.             m = k;
  341.             k++;
  342.             while (str[k] != '('&&str[k] != ')')
  343.                 k++;
  344.             if (str[k] == ')')
  345.             {
  346.                 n = k;
  347.                 flag = true;
  348.                 break;
  349.             }
  350.             else if (str[k] == '(')
  351.             {
  352.                 k--;
  353.             }
  355.         }
  356.         else
  357.         {
  358.             k++;
  359.         }
  360.     }
  361.     if (flag)
  362.     {
  363.         vector<char>sub;
  364.         for (int i = m+1; i < n ; i++)
  365.             sub.push_back(str[i]);
  366.         calculate_without_bracket(sub);
  367.         it = it + m - 1;
  368.         for (int i = 0; i < n + 1 - m;i++)
  369.         str.erase(it + 1, (it + 2 ));
  370.         int k = 0;
  371.         int len = sub.size();
  372.         while (k < len)
  373.         {
  374.             str.insert(it + k + 1, sub[k]);
  375.             k++;
  376.         }
  377.     }
  379.     return flag;
  380. }
  384. /*vector<char>char2vec(vector<char>&vec, char*str)
  385. {
  386.     while (*str != '\0')
  387.     {
  388.         vec.push_back(*str);
  389.         ++str;
  390.     }
  391.     return vec;
  392. }*/
  395. //整体表达式计算函数，每次调用erase_bracket函数先计算括号里的值
  396. //直到消除所有的括号，最后调用calculate_without_bracket计算剩下的无括号表达式的值
  397. int calculate(int len, char *expStr)
  398. {
  399.     vector<char>str;
  400.     for (int i = 0; i < len; i++)
  401.         str.push_back(expStr[i]);
  402.     bool flag = true;
  404.     while (flag)
  405.     {
  406.         flag = erase_bracket(str);
  407.     }
  409.     return calculate_without_bracket(str);
  411. }
  416. int _tmain(int argc, _TCHAR* argv[])
  417. {
  418.     /*vector<int>aa;
  419.     vector<int>::iterator it,ite;
  420.     for (int i = 0; i < 5; i++)
  421.     aa.push_back(i);
  422.     it = aa.begin()+3;
  423.     ite = it -2;
  424.     aa.erase(it-1,it+1);
  425.     aa.insert(ite+1, 9);*/
  428.     vector<char>vec;
  429.     //char2vec(vec, "2+10-30-2*9/4+3-7*9");
  430.     //cout << calculate_without_bracket(vec) << endl;
  431.     //int len=strlen("2+(5-14-2)*9/(4+3-17)*9");
  432.     int len = strlen("-3*(-200)-(-3*(-5-2*10)/(4+3-17)*9)");
  433.     cout << calculate(len, "-3*(-200)-(-3*(-5-2*10)/(4+3-17)*9)");
  435.     system("pause");
  436.     return 0;
  437. }

发表评论

表情：
评论列表 （有 0 条评论，346人围观）

还没有评论，来说两句吧...

相关阅读