免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
› 论坛 › 程序设计 › C/C++ › Linux 下实现计算器程序，高手请进！！
123
最近访问板块 发新帖
楼主: toddytao
打印 上一主题 下一主题

Linux 下实现计算器程序，高手请进！！ [复制链接]

starwing83

论坛徽章:
5
狮子座 日期:2013-08-20 10:12:24午马 日期:2013-11-23 18:04:102015年辞旧岁徽章 日期:2015-03-03 16:54:152015亚冠之德黑兰石油 日期:2015-06-29 18:11:1115-16赛季CBA联赛之新疆 日期:2024-02-21 10:00:53
21楼 [报告]
发表于 2011-08-10 10:47 |只看该作者
哥哥，你弄个github来传代码吧……
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
22楼 [报告]
发表于 2011-08-10 12:07 |只看该作者
修正英文数字正规表示法。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         if (tok_tab[i][len] == '\0') {
  74.                                 return i;
  75.                         }
  76.                 }
  77.         }
  78.         return -1;
  79. }

  81. int skip_word(const char *p, int *io_index, const char *s)
  82. {
  83.         int index;
  84.         int start, len;

  86.         if (p == NULL || io_index == NULL || s == NULL) {
  87.                 return -1;
  88.         }
  89.         index = *io_index;
  90.         if (index < 0) {
  91.                 return -1;
  92.         }
  93.         skip_space(p, &index);
  94.         if (get_word(p, &index, &start, &len) == 0) {
  95.                 if (strncmp(p + start, s, len) == 0) {
  96.                         *io_index = index;
  97.                         return 0;
  98.                 }
  99.         }
  100.         return -1;
  101. }

  103. int get_english_number_bellow_twenty(const char *p, int *io_index, int *o_value)
  104. {
  105.         static const char *digit20[20] = {
  106.                 "zero",
  107.                 "one",
  108.                 "two",
  109.                 "three",
  110.                 "four",
  111.                 "five",
  112.                 "six",
  113.                 "seven",
  114.                 "eight",
  115.                 "nine",
  116.                 "ten",
  117.                 "eleven",
  118.                 "twelve",
  119.                 "thirteen",
  120.                 "fourteen",
  121.                 "fifteen",
  122.                 "sixteen",
  123.                 "seventeen",
  124.                 "eighteen",
  125.                 "nineteen",
  126.         };
  127.         int index;
  128.         int start;
  129.         int len;
  130.         int tok;

  132.         if (p == NULL || io_index == NULL || o_value == NULL) {
  133.                 return -1;
  134.         }
  135.         index = *io_index;
  136.         if (index < 0) {
  137.                 return -1;
  138.         }
  139.         skip_space(p, &index);
  140.         if (get_word(p, &index, &start, &len) == 0) {
  141.                 tok = get_token(p + start, len, digit20, 20);
  142.                 if (tok != -1) {
  143.                         *o_value = tok;
  144.                         *io_index = index;
  145.                         return 0;
  146.                 }
  147.         }
  148.         return -1;
  149. }

  151. int get_english_number_decade(const char *p, int *io_index, int *o_value)
  152. {
  153.         static const char *decades[8] = {
  154.                 "twenty",
  155.                 "thirty",
  156.                 "forty",
  157.                 "fifty",
  158.                 "sixty",
  159.                 "seventy",
  160.                 "eighty",
  161.                 "ninety",
  162.         };
  163.         int index;
  164.         int start, len;
  165.         int value;
  166.         int retn;

  168.         if (p == NULL || io_index == NULL || o_value == NULL) {
  169.                 return -1;
  170.         }
  171.         index = *io_index;
  172.         if (index < 0) {
  173.                 return -1;
  174.         }
  175.         skip_space(p, &index);
  176.         if (get_word(p, &index, &start, &len) == 0) {
  177.                 retn = get_token(p + start, len, decades, 8);
  178.                 if (retn != -1) {
  179.                         value = retn * 10 + 20;
  180.                         *o_value = value;
  181.                         *io_index = index;
  182.                         return 0;
  183.                 }
  184.         }
  185.         return -1;
  186. }

  188. int get_english_number_bellow_hundred(const char *p, int *io_index, int *o_value)
  189. {
  190.         int index;
  191.         int value;
  192.         int digit;
  193.         int decade_yes;

  195.         if (p == NULL || io_index == NULL || o_value == NULL) {
  196.                 return -1;
  197.         }
  198.         index = *io_index;
  199.         if (index < 0) {
  200.                 return -1;
  201.         }
  202.         decade_yes = 0;
  203.         if (get_english_number_decade(p, &index, &value) == -1) {
  204.                 value = 0;
  205.         }else {
  206.                 decade_yes = 1;
  207.         }
  208.         if (get_english_number_bellow_twenty(p, &index, &digit) == 0) {
  209.                 if (decade_yes && digit == 0) {
  210.                         return -1;
  211.                 }
  212.                 value += digit;
  213.         }else {
  214.                 if (!decade_yes) {
  215.                         return -1;
  216.                 }
  217.         }
  218.         *o_value = value;
  219.         *io_index = index;
  220.         return 0;
  221. }

  223. int get_english_number_base(const char *p, int *io_index, int *o_base)
  224. {
  225.         static const char *more[] = {
  226.                 "thousand",
  227.                 "million",
  228.                 "billion",
  229.         };
  230.         static const int base[] = {
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_number_bellow_thousand(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;

  264.         if (p == NULL || io_index == NULL || o_value == NULL) {
  265.                 return -1;
  266.         }
  267.         index = *io_index;
  268.         if (index < 0) {
  269.                 return -1;
  270.         }
  271.         if (get_english_number_bellow_hundred(p, &index, &sum) == 0) {
  272.                 if (sum > 0 && sum < 10) {
  273.                         if (skip_word(p, &index, "hundred") == 0) {
  274.                                 sum *= 100;
  275.                                 if (skip_word(p, &index, "and") == 0) {
  276.                                         if (get_english_number_bellow_hundred(p, &index, &value) == -1) {
  277.                                                 return -1;
  278.                                         }
  279.                                         if (value == 0) {
  280.                                                 return -1;
  281.                                         }
  282.                                         sum += value;
  283.                                 }
  284.                         }
  285.                 }
  286.                 *o_value = sum;
  287.                 *io_index = index;
  288.                 return 0;
  289.         }else if (skip_word(p, &index, "a") == 0) {
  290.                 sum = 1;
  291.                 if (skip_word(p, &index, "hundred") == 0) {
  292.                         sum *= 100;
  293.                         if (skip_word(p, &index, "and") == 0) {
  294.                                 if (get_english_number_bellow_hundred(p, &index, &value) == -1) {
  295.                                         return -1;
  296.                                 }
  297.                                 if (value == 0) {
  298.                                         return -1;
  299.                                 }
  300.                                 sum += + value;
  301.                         }
  302.                 }
  303.                 *o_value = sum;
  304.                 *io_index = index;
  305.                 return 0;
  306.         }
  307.         return -1;
  308. }

  310. int get_english_number(const char *p, int *io_index, int *o_value)
  311. {
  312.         int index;
  313.         int value;
  314.         int sum;
  315.         int base;
  316.        
  317.         if (p == NULL || io_index == NULL || o_value == NULL) {
  318.                 return -1;
  319.         }
  320.         index = *io_index;
  321.         if (index < 0) {
  322.                 return -1;
  323.         }
  324.         sum = 0;
  325.         for (;;) {
  326.                 if (get_english_number_bellow_thousand(p, &index, &value) == 0) {
  327.                         if (value == 0) {
  328.                                 break;
  329.                         }
  330.                         if (get_english_number_base(p, &index, &base) == 0) {
  331.                                 value *= base;
  332.                                 if (sum > 0 && value >= sum) {
  333.                                         return -1;
  334.                                 }
  335.                                 sum += value;
  336.                                 continue;
  337.                         }
  338.                         sum += value;
  339.                 }
  340.                 if (sum == 0) {
  341.                         return -1;
  342.                 }
  343.                 break;
  344.         }
  345.         *o_value = sum;
  346.         *io_index = index;
  347.         return 0;
  348. }

  350. int get_operator1(const char *p, int *io_index, int *o_op)
  351. {
  352.         static const char *op_list[] = {
  353.                 "positive",
  354.                 "+",
  355.                 "negative",
  356.                 "-",
  357.         };
  358.         int index;
  359.         int start, len;
  360.         int retn;
  361.        
  362.         if (p == NULL || io_index == NULL || o_op == NULL) {
  363.                 return -1;
  364.         }
  365.         index = *io_index;
  366.         if (index < 0) {
  367.                 return -1;
  368.         }
  369.         skip_space(p, &index);
  370.         if (get_word(p, &index, &start, &len) == 0) {
  371.                 retn = get_token(p + start, len, op_list, 8);
  372.                 if (retn != -1) {
  373.                         *o_op = retn / 2;
  374.                         *io_index = index;
  375.                         return 0;
  376.                 }
  377.         }
  378.         return -1;
  379. }

  381. int get_operator2(const char *p, int *io_index, int *o_op)
  382. {
  383.         static const char *op_list[] = {
  384.                 "plus",
  385.                 "+",
  386.                 "minus",
  387.                 "-",
  388.                 "multiply",
  389.                 "*",
  390.                 "divide",
  391.                 "/",
  392.         };
  393.         int index;
  394.         int start, len;
  395.         int retn;

  397.         if (p == NULL || io_index == NULL || o_op == NULL) {
  398.                 return -1;
  399.         }
  400.         index = *io_index;
  401.         if (index < 0) {
  402.                 return -1;
  403.         }
  404.         skip_space(p, &index);
  405.         if (get_word(p, &index, &start, &len) == 0) {
  406.                 retn = get_token(p + start, len, op_list, 8);
  407.                 if (retn != -1) {
  408.                         if ((retn & 1) == 0) {
  409.                                 skip_word(p, &index, "with");
  410.                         }
  411.                         *o_op = retn / 2;
  412.                         *io_index = index;
  413.                         return 0;
  414.                 }
  415.         }
  416.         return -1;
  417. }

  419. int get_arab_number(const char *p, int *io_index, int *o_value)
  420. {
  421.         int index;
  422.         int value;

  424.         if (p == NULL || io_index == NULL || o_value == NULL) {
  425.                 return -1;
  426.         }
  427.         index = *io_index;
  428.         if (index < 0) {
  429.                 return -1;
  430.         }
  431.         skip_space(p, &index);
  432.         if (isdigit(p[index])) {
  433.                 value = 0;
  434.                 do {
  435.                         value = value * 10 + p[index] - '0';
  436.                         index++;
  437.                 }while (isdigit(p[index]));
  438.                 *o_value = value;
  439.                 *io_index = index;
  440.                 return 0;
  441.         }
  442.         return -1;
  443. }

  445. int get_number(const char *p, int *io_index, int *o_value)
  446. {
  447.         int index;
  448.         int value;

  450.         if (p == NULL || io_index == NULL || o_value == NULL) {
  451.                 return -1;
  452.         }
  453.         index = *io_index;
  454.         if (index < 0) {
  455.                 return -1;
  456.         }
  457.         if (get_english_number(p, &index, &value) == 0
  458.                 || get_arab_number(p, &index, &value) == 0) {
  459.                 *o_value = value;
  460.                 *io_index = index;
  461.                 return 0;
  462.         }
  463.         return -1;
  464. }

  466. int get_oprand(const char *p, int *io_index, int *o_value)
  467. {
  468.         int index;
  469.         int op;
  470.         int d1;
  471.         int result;

  473.         if (p == NULL || io_index == NULL || o_value == NULL) {
  474.                 return -1;
  475.         }
  476.         index = *io_index;
  477.         if (index < 0) {
  478.                 return -1;
  479.         }
  480.         /* one oprand operation */
  481.         if (get_operator1(p, &index, &op) == 0) {
  482.                 if (get_number(p, &index, &d1) != 0) {
  483.                         return -1;
  484.                 }
  485.                 switch (op) {
  486.                 case 0:
  487.                         result = d1;
  488.                         break;
  489.                 case 1:
  490.                         result = -d1;
  491.                         break;
  492.                 default:
  493.                         return -1;
  494.                 }
  495.         }else {
  496.                 if (get_number(p, &index, &result) != 0) {
  497.                         return -1;
  498.                 }
  499.         }
  500.         *o_value = result;
  501.         *io_index = index;
  502.         return 0;
  503. }

  505. int get_end(const char *p, int *io_index)
  506. {
  507.         int index;

  509.         if (p == NULL || io_index == NULL) {
  510.                 return -1;
  511.         }
  512.         index = *io_index;
  513.         if (index < 0) {
  514.                 return -1;
  515.         }
  516.         skip_space(p, &index);
  517.         if (p[index] == '\0') {
  518.                 *io_index = index;
  519.                 return 0;
  520.         }
  521.         return -1;
  522. }

  524. int caculate(const char *exp, int *o_value)
  525. {
  526.         int op; /* operator */
  527.         int d1, d2; /* oprand number */
  528.         int result; /* store the expression result */
  529.         int index;

  531.         if (exp == NULL || o_value == NULL) {
  532.                 return -1;
  533.         }
  534.         index = 0;
  535.         if (get_oprand(exp, &index, &result) == -1) {
  536.                 return -1;
  537.         }
  538.         /* conjunction operation */
  539.         while (get_end(exp, &index) == -1) {
  540.                 /* two oprands operation */
  541.                 d1 = result;
  542.                 if (get_operator2(exp, &index, &op) == -1) {
  543.                         return -1;
  544.                 }
  545.                 if (get_oprand(exp, &index, &d2) == -1) {
  546.                         return -1;
  547.                 }
  548.                 switch (op) {
  549.                 case 0:
  550.                         result = d1 + d2;
  551.                         break;
  552.                 case 1:
  553.                         result = d1 - d2;
  554.                         break;
  555.                 case 2:
  556.                         result = d1 * d2;
  557.                         break;
  558.                 case 3:
  559.                         if (d2 == 0) {
  560.                                 return -1;
  561.                         }
  562.                         result = d1 / d2;
  563.                         break;
  564.                 default:
  565.                         return -1;
  566.                 }
  567.         }
  568.         *o_value = result;
  569.         return 0; /* end of conjunction */
  570. }

  572. int read_line(char *buff, int buf_len)
  573. {
  574.         int len;

  576.         if (buff == NULL || buf_len <= 0) {
  577.                 return -1;
  578.         }
  579.         for (;;) {
  580.                 if (fgets(buff, buf_len, stdin) == NULL) {
  581.                         return -1;
  582.                 }
  583.                 len = strlen(buff) - 1;
  584.                 if (buff[len] == '\n') {
  585.                         buff[len] = '\0';
  586.                         return 0;
  587.                 }
  588.                 /* check for last not terminated line in file */
  589.                 if (fgets(buff, buf_len, stdin) == NULL) {
  590.                         return 0;
  591.                 }
  592.                 /* line length is greater than buffer */
  593.                 /* skip rest line content */
  594.                 for (;;) {
  595.                         len = strlen(buff) - 1;
  596.                         if (buff[len] == '\n') {
  597.                                 return -2; /* buffer overflow, skip the whole line */
  598.                         }
  599.                         if (fgets(buff, buf_len, stdin) == NULL) {
  600.                                 return -1;
  601.                         }
  602.                 }
  603.         }
  604. }

  606. int main(void)
  607. {
  608.         char cmd_line[1024];
  609.         int result;

  611.         puts("English Caculator");
  612.         puts("Enter an expression");
  613.         puts("Ctrl-Z to exit\n");
  614.         for (;;) {
  615.                 printf(": ");
  616.                 switch (read_line(cmd_line, sizeof(cmd_line))) {
  617.                 case 0:
  618.                         break;
  619.                 default:
  620.                 case -1:
  621.                         puts("");
  622.                         return 0;
  623.                 case -2:
  624.                         puts("Buffer Overflow");
  625.                         continue;
  626.                 }
  627.                 if (caculate(cmd_line, &result) == 0) {
  628.                         printf("'%s' = %d\n", cmd_line, result);
  629.                 }else {
  630.                         printf("'%s' = E, Invalid Expression\n", cmd_line);
  631.                 }
  632.         }
  633. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
zylthinking

论坛徽章:
11
未羊 日期:2013-12-16 12:45:4615-16赛季CBA联赛之青岛 日期:2016-04-11 19:17:4715-16赛季CBA联赛之广夏 日期:2016-04-06 16:34:012015亚冠之卡尔希纳萨夫 日期:2015-11-10 10:04:522015亚冠之大阪钢巴 日期:2015-07-30 18:29:402015亚冠之城南 日期:2015-06-15 17:56:392015亚冠之卡尔希纳萨夫 日期:2015-05-15 15:19:272015亚冠之山东鲁能 日期:2015-05-14 12:38:13金牛座 日期:2014-12-04 15:34:06子鼠 日期:2014-10-16 13:40:4715-16赛季CBA联赛之八一 日期:2016-07-22 09:41:40
23楼 [报告]
发表于 2011-08-10 12:13 |只看该作者
真闲
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
sudayly

论坛徽章:
0
24楼 [报告]
发表于 2011-08-10 21:23 |只看该作者
回复 1# toddytao


    我觉的应该分两步分析，首先把英文转化成数字和加减乘除符号，然后使用数字和加减乘除的计算器就容易实现了。
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
toddytao

论坛徽章:
0
25楼 [报告]
发表于 2011-08-11 15:52 |只看该作者
回复 24# sudayly


大哥。。。我的思路和你差不多。。已经完成了。。。等了好久没有回复。。。我自己写了个。。。
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
toddytao

论坛徽章:
0
26楼 [报告]
发表于 2011-08-11 15:53 |只看该作者
回复 22# cobras


大哥。。谢谢你的回复。。。辛苦了。。。。我已经完成了。。自己写了个。。
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
jin_xu_csu

论坛徽章:
0
27楼 [报告]
发表于 2011-08-14 20:10 |只看该作者
不错，C很强大啊
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
123
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号：11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们：huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP