c语言强化训练——简易计算器

 

一、设计要求

实现一个简单的计算器，要求可以求解表达式，支持基本的运算并有扩展能力和基本的容错能力

 

二、设计思路

程序需要定义两个工作栈，分别保存表达式计算过程中的运算符与运算数，通过一个优先级表来判定运算顺序。通过判定输入的运算符来调用不同的函数，实现支持基本的运算符号。可以通过定义一个运算符表和一个函数指针表，通过查找方式调用函数，实现运算符的可扩展性。

 

三、详细设计

１、首先需要编写一个栈，这个栈需要支持浮点数和字符，编写这个栈stack.h文件

typedef struct {        char * buffer;        int typesize;        int top;        int max;} Stack;Stack * CreateStack(int max, int typesize);void DestroyStack(Stack *);void ClearStack(Stack *);int Push(Stack *, void *);int Pop(Stack *, void *);int GetElement(Stack*, unsigned int n, void *);int GetTop(Stack *, void *);int IsEmpty(Stack *);int IsFull(Stack *);Stack * CreateStack(int max, int typesize){        Stack * s = (Stack*)malloc(sizeof(Stack));        if (!s) return 0;        s->buffer = (char *)malloc(sizeof(char) * max * typesize);        if (!s->buffer) return 0;        s->top = -1;        s->max = max;        s->typesize = typesize;        return s;}void DestroyStack(Stack* s){        free(s->buffer);        free(s);}void ClearStack(Stack * s){        s->top = -1;}int Push(Stack * s, void * data){        if (IsFull(s)) return 0;        s->top++;        memcpy(s->buffer + s->top*s->typesize, data, s->typesize);        return 1;}int Pop(Stack * s, void * data){        if (IsEmpty(s)) return 0;        memcpy(data, s->buffer + s->top*s->typesize, s->typesize);        s->top--;        return 1;}int GetTop(Stack *s, void * data){        if (IsEmpty(s)) return 0;                memcpy(data, s->buffer + s->top*s->typesize, s->typesize);                return 1;}int IsEmpty(Stack * s){        return s->top == -1;}int IsFull(Stack * s){        return s->top == s->max-1;}

 

２、下面编写calcu.c文件，实现计算器功能，首先引入需要的头文件

#include "stdlib.h"#include "stack.h"

３、对于用户输入的字符串要进行解析成运算符和数值，可以通过一个数组A来保存，再定义一个标记位数组B，标记数组A中哪一位是数据，哪一位是运算符。为了更明确数据与标记位的关系，这里把二者定义成一个结构体，通过结构体数据接受解析结果

#define fldouble 0#define flchar 1typedef struct {        double data;        char flag;} cal;

４、定义支持的运算符，通过一个函数查找某个字符在运算符表中的位置，若不存在则返回-1

int SearchCode(char ch){        char * code = "+-*/^()#";        int n  = 0;        while (code[n])        {                if (code[n] == ch) return n;                n++;        }        return -1;}

５、定义优先级表，控制运算过程中运算顺序，传入的参数为ｓｃｈ：栈中字符，ｎｃｈ下一个字符，返回优先级顺序

char GetPerferen(char sch, char nch){        char perferen[8][8] = {                ">><<<<>>",                ">><<<<>>",                ">>>><<>>",                ">>>><<>>",                ">>>>><>>",                "<<<<<<=E",                ">>>>>E>>",                "<<<<<<E="        };        int s = SearchCode(sch);        int n = SearchCode(nch);        if (s==-1 || n==-1) return 'E';        return perferen[s][n];} rs;}double calcu(double a, char ch, double b){        double (*function[5])(double,double) = {add,sub,mul,ddiv,mi};        return function[SearchCode(ch)](a,b);}

６、定义支持的运算函数，和一个查找函数指针列表的函数，函数指针列表中的运算函数与运算符表一一对应

double add(double a, double b) { return a+b; }double sub(double a, double b) { return a-b; }double mul(double a, double b) { return a*b; }double ddiv(double a, double b) { return a/b; }double mi(double a, double b){        int n = 1;        double rs = a;        for (n=1; nreturn

７、编写函数检查用户输入的字符串是否合法，若含有结束符＃，或不是有效运算符，不是数字且不是小数点，则视为非法字符，返回０。若字符串合法，在字符串末尾加入运算结束符＃

int CheckStr(char * buffer){        int n = -1;        while (buffer[++n])        {                if ((SearchCode(buffer[n]) != -1 ||                         buffer[n] == '.' ||                          (buffer[n] >= '0' && buffer[n] <= '9'))                           && buffer[n] != '#')                        continue;                else                        return 0;        }        buffer[n] = '#';        buffer[n+1] = 0;        return 1;}

８、解析过程是遍历字符串的过程，首先判断当前字符是否为运算符，若不是运算符调用一个函数GetNextValue获取这个数值。若是运算符但为加号或减号，需要判断是正负号还是加减号，再分别处理

首先编写GetNextValue函数，这个函数需要字符串指针，和指向解析过程中计数器的指针，接收结果的指针。若数值中有多个小数点或者小数点出现在第一位或最后一位，则非法，返回０，成功则返回１

int GetNextValue(char * buffer, int * n, double * rs){        char str[30];        int ii=0,ij = 0;        while (SearchCode(buffer[*n]) == -1)        {                str[ii++] = buffer[*n];                (*n)++;        }        str[ii] = 0;        ii=0;        while (str[ii])        {                if (str[ii++] == '.') ij++;        }        if (ij>1 || str[ii-1] == '.' || str[0] == '.') return 0;        *rs = atof(str);        return 1;}

９、解析函数需要传入用户输入的字符串指针和接受解析结果的指针，成功返回０，失败返回１

int resolu(char * buffer, cal * calstr){        int bn = 0, cn = 0;        cal c;        while (buffer[bn])        {                if (SearchCode(buffer[bn]) == -1)                {                        if (!GetNextValue(buffer,&bn, &c.data)) return 0;                        c.flag = fldouble;                        calstr[cn++] = c;                }                else                {                        if ((buffer[bn] == '-' && buffer[bn-1] == '(') || (bn==0 && buffer[0] == '-'))                        {                        bn++;                                if (!GetNextValue(buffer,&bn, &c.data)) return 0;                                c.data = 0 - c.data;                                c.flag = fldouble;                                calstr[cn++] = c;                        }                        if ((buffer[bn] == '+' && buffer[bn-1] == '(') || (bn==0 && buffer[0] == '+'))                        {                        bn++;                                if (!GetNextValue(buffer, &bn, &c.data)) return 0;                                c.flag = fldouble;                                calstr[cn++] = c;                        }                        else                        {                                c.data = (double)buffer[bn++];                                c.flag = flchar;                                calstr[cn++] = c;                        }                                        }        }}

１０、运算函数

运算过程需要两个工作栈，当符号栈顶和解析串的下一个字符均为＃时，表示运算结束。结束后数值栈应该只有一个元素，这个元素就是结果。这个函数需要传入指向解析结果的指针，和一个接收运算结果的指针，返回计算是否成功

int result(cal * calstr, double * rs){        Stack * pst = CreateStack(100,sizeof(char));        Stack * pnd = CreateStack(100,sizeof(double));        double num1,num2;        int n = 0;        char ch = '#';        Push(pst, &ch);        while(ch != '#' || !(calstr[n].flag == flchar && (char)calstr[n].data == '#'))        {                if (calstr[n].flag == fldouble)                {                        Push(pnd, &(calstr[n].data));                        n++;                }                else                {                        switch( GetPerferen(ch, (char)calstr[n].data))                        {                        case '<':                                ch = (char)calstr[n].data;                                Push(pst, &ch);                                n++;                                break;                        case '=':                                if (!Pop(pst, &ch)) return 0;;                                n++;                                break;                        case '>':                                if (!(Pop(pnd,&num2) && Pop(pst,&ch) && Pop(pnd,&num1))) return 0;;                                num1 = calcu(num1,ch,num2);                                Push(pnd, &num1);                                break;                        case 'E':                                return 0;                        }                }                if (!GetTop(pst, &ch)) return 0;        }        if (GetSize(pnd) == 1 && GetTop(pnd,rs))        {                DestroyStack(pst);                DestroyStack(pnd);                return 1;        }        else        {                return 0;        }}

１１、编写与用户交互的函数

void treatment(){        char buffer[100];        cal calstr[50];        double rs;        printf("calcu>");        gets(buffer);        while (!(buffer[0]=='e' && buffer[1]=='x' && buffer[2]=='i' && buffer[3]=='t'))        {                if (CheckStr(buffer) && resolu(buffer,calstr) && result(calstr,&rs))                {                        printf("/n%f/n",rs);                }                else                {                        printf("/nError!/n");                }                printf("/ncalcu>");                gets(buffer);        }        printf("/nbye/n");}

 

１２、主函数

main(){        printf("Copyright/n/n");        treatment();}

四、测试

程序在TC2.0环境下测试通过

 

        （I）正常检测：
                （1）运算情况是否正确检测：
                          1.12+3*（3*4^3+3.12542*(1+2)）/（4.2-1）+2.1 = 192.01024375
 
               （2）负数运算检测：
                         -2.1+((-2)^2）= 1.9

               （3）正数运算检测：
                         +2.1+((+2)^2)
              
               （4）单数字输入运算检测：
                         1  = 1.00000
            

        （II）容错检测：
                 （1）小数点输入错误检测：
                           1.22.+3..234..
                            .1+2

                （2）括号是否匹配检测：
                          ((2+3)/(5/4.1)))
 
                （3）运算符输入错误检测：
                          2.1--2
                          2.1++2
                          2.1**2
                          2.1//2
                          2.1^^2

                （4）字符串输入错误检测：
                          1+3.1+5=
                          1#3.3
                           #                          
                           (())
                           回车
                           空格