pnd1 c语言,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 1
typedef 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>>",
"<<<<<
};
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 # (()) 回车 空格