c语言 电力计算的编程,C语言如何计算表达式

给你贴一个我以前写我程序，和你要求的功能差不多，只是这个支持小数，允许自己输入表达式，有比较完备的错误检查。

程序代码：#include

#include

#include

#define SIZE1 20 //栈的大小

#define SIZE2 100 //表达式的最大长度

int check(char ch[]); //检查表达式是否合乎规则

double convert(int *place); //将表达式中的表示数字的字符串转化为双精度数

int OPSWR(char c); //将运算符c存入运算符栈

int OVSWR(double s); //将数s存入数字栈

int OPSRE(char *c); //将处于运算栈顶的运算符取出

int OVSRE(double *s); //同上

int OPSDEL(); //将运算符栈栈顶的运算符清除

int OVSDEL(); //同上

int ERRORINF(int flag); //检查错误信息

int CALCULATE(); //主要功能的实现部分，运算原理的实现部分

int COMP(); //数值计算

// 运算符栈，top表示栈顶的位置

struct OPSSTA {

char stack[SIZE1];

int top;

} OPS;

//同上

struct OVSSTA {

double stack[SIZE1];

int top;

} OVS;

double RESULT;

char str[SIZE2],str1[SIZE1];

int main () {

int flag=0,sign=0;

OPS.top=-1;

OVS.top=-1;

printf("请输入表达式：");

gets(str);

strcpy(str1,str);

flag=check(str);

sign=ERRORINF(flag);

if(sign!=1) {

getch();

return -1;

}

flag=CALCULATE();

sign=ERRORINF(flag);

if(sign!=1) {

getch();

return -1;

}

else

printf("\n%s = %.10f",str1,RESULT);

getch();

return 1;

}

int check(char ch[]) {

int i=0,j=0,left=0,right=0;

for(i=0;ch[i]!='\0';i++) {

if(ch[i]>='('&&ch[i]<='9') {

if(ch[i]=='(')

left++;

if(ch[i]==')')

right++;

if(ch[i]==44)

return -1;

}

}

ch[i]=';';

ch[i+1]='\0';

if(left!=right)

return -1;

for(i=0;ch[i]!='\0';i++) {

if(ch[i]>='0'&&ch[i]<='9')

continue;

if(ch[i]=='.')

if(!((ch[i+1]>='0'&&ch[i+1]<='9')&&(ch[i-1]>='0'&&ch[i-1]<='9')))

return -1;

if(ch[i]=='+'||ch[i]=='-'||ch[i]=='*'||ch[i]=='/') {

if(!((ch[i+1]>='0'&&ch[i+1]<='9'||ch[i+1]=='(')&&(ch[i-1]>='0'&&ch[i-1]<='9'||ch[i-1]=='(')))

return -1;

continue;

}

if(ch[i]=='(')

if(ch[i-1]>='0'&&ch[i-1]<='9')

return -1;

if(ch[i]==')')

if(ch[i+1]>='0'&&ch[i+1]<='9')

return -1;

}

return 1;

}

int ERRORINF(int flag) {

switch(flag) {

case 1:

return 1;

case -1:

printf("表达式格式错误！");

return 0;

case -2:

printf("栈OPS溢出！");

return 0;

case -3:

printf("除0！");

return 0;

case -4:

printf("栈OVS溢出！");

return 0;

case -5:

printf("栈OVS访问越界！");

return 0;

case -6:

printf("栈OPS访问越界！");

return 0;

default:

printf("程序运行错误！");

return 0;

}

}

double convert(int *place) {

char num[SIZE1];

int i=0,j=*place;

for(;str[j]>='0'&&str[j]<='9'||str[j]=='.';j++,i++)

num[i]=str[j];

num[i]='\0';

*place=j;

return atof(num);

}

int OPSWR(char c) {

OPS.top++;

if(OPS.top>=SIZE1)

return -2;

OPS.stack[OPS.top]=c;

return 1;

}

int OVSWR(double s) {

OVS.top++;

if(OVS.top>=SIZE1)

return -4;

OVS.stack[OVS.top]=s;

return 1;

}

int OPSRE(char *c) {

if(OPS.top<0)

return -5;

else {

*c=OPS.stack[OPS.top];

OPSDEL();

}

return 1;

}

int OVSRE(double *s) {

if(OVS.top<0)

return -6;

else {

*s=OVS.stack[OVS.top];

OVSDEL();

}

return 1;

}

int OPSDEL() {

if(OPS.top<0)

return -5;

else {

OPS.stack[OPS.top]='\0';

OPS.top--;

}

return 1;

}

int OVSDEL() {

if(OVS.top<0)

return -6;

else {

OVS.stack[OVS.top]=0;

OVS.top--;

}

return 1;

}

int CALCULATE() {

int place,flag=0;

double RES;

flag=OPSWR(';');

if(flag!=1)

return flag;

for(place=0;str[place]!='\0';place++) {

flag=0;

if(str[place]>='0'&&str[place]<='9') {

RES=convert(&place);

place--;

flag=OVSWR(RES);

if(flag!=1)

return flag;

continue;

}

if(str[place]=='(') {

flag=OPSWR('(');

if(flag!=1)

return flag;

continue;

}

if(str[place]==')') {

if(OPS.stack[OPS.top]!='(') {

flag=COMP();

if(flag!=1)

return flag;

place--;

continue;

}

else {

flag=OPSDEL();

if(flag!=1) {

return flag;

}

}

continue;

}

if(str[place]=='+'||str[place]=='-') {

if(OPS.stack[OPS.top]=='('||OPS.stack[OPS.top]==';') {

flag=OPSWR(str[place]);

if(flag!=1) {

return flag;

}

continue;

}

else {

flag=COMP();

if(flag!=1)

return flag;

place--;

continue;

}

}

if(str[place]=='*'||str[place]=='/') {

if(OPS.stack[OPS.top]=='*'||OPS.stack[OPS.top]=='/') {

flag=COMP();

if(flag!=1)

return flag;

place--;

continue;

}

else {

flag=OPSWR(str[place]);

if(flag!=1)

return flag;

continue;

}

}

if(str[place]==';') {

if(OPS.stack[OPS.top]==';') {

RESULT=OVS.stack[OVS.top];

return 1;

}

else {

flag=COMP();

if(flag!=1) {

return flag;

}

place--;

continue;

}

}

return -1;

}

return 1;

}

int COMP() {

int flag;

double A,B,RES;

char ops;

flag=OPSRE(&ops);

if(flag!=1) {

return flag;

}

flag=OVSRE(&B);

if(flag!=1) {

return flag;

}

flag=OVSRE(&A);

if(flag!=1) {

return flag;

}

switch(ops) {

case '+':

RES=A+B;

break;

case '-':

RES=A-B;

break;

case '*':

RES=A*B;

break;

case '/':

if(B==0.0)

return -3;

RES=A/B;

break;

default:

return -1;

}

flag=OVSWR(RES);

if(flag!=1) {

return flag;

}

return 1;

}