C++ 编写计算器 附带自动查错功能（输入表达式输出运算结果）

好久没写随笔了啊。 这几天都在上课，还有准备今年的区域赛，在整理数据结构模板的时候，把去年大二上学期编的一个程序找了出来，和大家分享下，互相交流。

当时老师布置的作业，C++编写一个计算器，实现如下功能：

1.输入形如如同 1+3*5= 的表达式，输出运算结果。 输入包含数字 + - * / 括号 数学函数



2.自动查错 若输入表达式不合法(1++3-2)，比如 1*2+5-3)= 要提示在第3个位置缺少左括号（当然位置不唯一，位置是从0开始计数）。

再比如1.5+6/0= 或者 1.5.5+3= 要分别提示除数为0 在第3个位置出现多余小数点。







3.实现一些数学函数 我这里只选用了3个三角函数sin() cos() tan()

4.带括号和优先级判断 比如 1+(5-2)-3*9= 先计算(5-2) 在计算3*9 总之是先括号，再乘除，最后加减。

5.能够灵活处理正负号 比如一些特殊的输入1+sin(-(-(-3.14)))=

当时自己写了一个程序，帮同班另一女同学也写了一个，感觉不难，思路是肯定有的，只是写代码有点麻烦，搞了一晚上，新鲜的C++计算器出炉了（小程序求大家不要笑）。

下面说说大体思路吧

首先读入表达式

然后把表达式中空格和一些无效字符删除，字符全部变成小写，便于后面比较。

然后查错 查错分 是否有非法字符，是否括号匹配 ，是否缺少运算符等等。括号匹配这个直接用一个栈来判定即可，其它的讨论下。

当然要顺便记录每对括号匹配的位置，因为后面要用，有递归实现求值功能。

然后计算数值，采用递归的写法。比如表达式 3+sin(3.14+2) 先计算位置0到length这个区间的数值，然后递归计算3+位置2到位置length这个区间的数值，这样是相当方便的。

至于计算数值的话，考虑有括号和+-*/优先级 我采用后缀表达式计算，也就是逆波兰式。 把运算符+-*/映射成很小的实数 当然要保证这些实数不会出现在操作数里面，具体的逆波兰式计算表达式，百度知道，数据结构里面也学了的。

如果运算中出现很小的负数可能会出问题，因为我符号的hash也映射成负数的，根据情况改一下const double inf和const double eps即可！

自己验证了许多数据，都能输出正确结果，如果大家有发现BUG的，希望留言，我已经把这个弄成计算表达式的模板了。

代码

Calc.h

#ifndef CALC_H_INCLUDED
#define CALC_H_INCLUDED

#include<cstdio>

const int MAXN = 200;

class Calc{
private:
char Exp[MAXN];			//表达式
int NextB[MAXN];		//匹配括号位置
double Ans;				//求值结果
void DelandLower(char *str);		//删除空字符 转化为小写
bool Check(char *str,int & len);
bool CheckCh(const char *str,int pos);	//检查字符
bool Is_Num(char c);		//是否为数字
bool Operat(char c);		//是否为运算符
bool CheckError(const char *str,int len);
bool CrectB(const char *str);		//检查括号匹配
bool Equal(double a,double b);		//判断浮点数相等
int Prio(double x);				//符号优先级判断
double hash(char c);			//符号到浮点型映射
double GetV(const char *str,int st,int ed);		//区间求值
public:
void Input(){gets(Exp);}
void Output(){printf("%.2f\n",Ans);}
bool Cac();
};

#endif // CALC_H_INCLUDED

　　

Calc.cpp

#include"Calc.h"
#include<stack>
#include<cmath>
#include <cstring>
#include <iostream>

const double inf = 1e11;
const double eps = 1e-6; //eps 调整精度
const int MAXFUN = 3;

#define HASHA (-inf+1)
#define HASHS (-inf+2)
#define HASHM (-inf+3)
#define HASHD (-inf+4)
#define HASHL (-inf+5)
#define ERRORX (-inf+6)

using namespace std;

static char MathFun[][4]={"sin","cos","tan"};

double Calc::hash(char c){
switch(c){
case '+':return HASHA;
case '-':return HASHS;
case '*':return HASHM;
case '/':return HASHD;
default :return HASHL;
}
}

int Calc::Prio(double x){
if(x<-inf+3-eps)  //代表加法和减法
return 1;
if(x<-inf+5-eps) //乘法和除法
return 2;
return 3;
}

void Calc::DelandLower(char *str){
int i,j;
for(i=j=0;*(str+i);i++){
if(*(str+i)==' ' || *(str+i)=='\t')
continue;
if(*(str+i)>='A' && *(str+i)<='Z')
*(str+i)+='a'-'A';
*(str+j)=*(str+i);
j++;
}
*(str+j)=0;
}

bool Calc::Operat(char c){
switch(c){
case '+':
case '-':
case '*':
case '/':return 1;
default :return 0;
}
}

bool Calc::Is_Num(char c){
return c>=48 && c<=57;
}

bool Calc::CheckCh(const char *str,int pos)
{
int i,j,k; //i扫描到字符串第i个字符，j控制行，k控制列

for(i=pos;*(str+i);i++){
if(Is_Num(*(str+i))
|| Operat(*(str+i)) || *(str+i)=='.'
|| *(str+i)=='(' || *(str+i)==')')
continue;
for(j=0;j<MAXFUN;j++){
for(k=0;k<MAXFUN;k++){
if(*(str+i+k)!=*(*(MathFun+j)+k)) //递归调用MathFun 检查是否匹配数学函数
break;
}
if(k>=3)
break;
}
if(j>=3){
printf("在%d位置出现非法字符\n",i);
return 0;
}
else{
if(*(str+i+3)!='('){
printf("在%d位置缺少左括号\n",i+3);
return 0;
}
return CheckCh(str,i+3);
}
}
return 1;
}

bool Calc::CrectB(const char *str)
{
stack<int> s;

for(int i=0;*(str+i);i++){
if(*(str+i)!='(' && *(str+i)!=')')
continue;
if(*(str+i)=='('){
s.push(i);
}
else
if(s.empty()){
printf("在%d位置出现多余右括号\n",i);
return 0;
}
else{
NextB[s.top()]=i;
s.pop();
}
}
if(!s.empty()){
printf("在%d位置出现多余左括号\n",s.top());
return 0;
}
return 1;
}

bool Calc::CheckError(const char *str,int len){
for(int i=0;i<len;i++){
if(*(str+i)=='('){
if(i<len-1 && Operat(str[i+1]) && str[i+1]!='-'){
printf("在%d位置缺少运算符\n",i+1);
return 0;
}
if(i>0 && (Is_Num(str[i-1]) || str[i-1]==')')){
printf("在%d位置缺少运算符\n",i);
return 0;
}
}
else
if(*(str+i)==')'){
if(i>0 && (Operat(str[i-1]) || str[i-1]=='(')){
if(Operat(str[i-1]))
printf("在%d位置缺少运算符\n",i);
else
printf("在%d位置缺少数字\n",i);
return 0;
}
if(i<len-1 && Is_Num(str[i+1])){
printf("在%d位置缺少运算符\n",i+1);
return 0;
}
}
else
if(i>0 && Operat(*(str+i)) && Operat(str[i-1])){
printf("在%d位置缺少数字\n",i);
return 0;
}
}
return 1;
}

bool Calc::Check(char *str,int & len){
if(len<(1<<1)){
puts("表达式长度异常");
return 0;
}
if(str[len-1]!='=' || Operat(str[len-2])){
puts("表达式结尾错误");
return 0;
}
str[--len]=0;
if(!CheckCh(str,0) || !CrectB(str) || !CheckError(str,len))
return 0;
return 1;
}
bool Calc::Equal(double a,double b){
if(fabs(a-b)<eps)
return 1;
return 0;
}

double Calc::GetV(const char *str,int st,int ed){
struct P{
double x,flag;
bool point;
int sign;
P(){Init();}
void Init(){
x=0.0;flag=1e-1;
sign=1;point=0;
}
}Num;
stack<double> S;
double *Suffix=new double[ed-st+1];
int sz=0;
int i;
for(i=st;i<ed;i++){
if(Is_Num(*(str+i)) || *(str+i)=='.')
if(*(str+i)=='.')
if(Num.point==1){
printf("在%d位置出现多余小数点\n",i);
return ERRORX;
}
else
Num.point=1;
else
if(Num.point==1){
Num.x+=Num.flag*(*(str+i)-48);
Num.flag*=1e-1;
}
else
Num.x=Num.x*1e1+(*(str+i)-48);
else{
if(i>st && Is_Num(str[i-1])){
Suffix[sz++]=Num.x*Num.sign;
Num.Init();
}
if(*(str+i)=='s' || *(str+i)=='c' || *(str+i)=='t'){
double ret=0.0;
switch(*(str+i)){
case 's':ret=sin(GetV(str,i+4,NextB[i+3]));break;
case 'c':ret=cos(GetV(str,i+4,NextB[i+3]));break;
default :ret=tan(GetV(str,i+4,NextB[i+3]));
}
if(Equal(ret,ERRORX))
return ERRORX;
Num.x=ret;
Suffix[sz++]=Num.x*Num.sign;
Num.Init();
i=NextB[i+3];
}
else
if(*(str+i)==')'){
while(!S.empty() && !Equal(HASHL,S.top())){
Suffix[sz++]=S.top();
S.pop();
}
S.pop();
}
else{
char c=*(str+i);
if(*(str+i)=='-'){
Num.sign=-Num.sign;
if(i>st && str[i-1]!='(')
c='+';
else
continue;
}
while(!S.empty() && !Equal(S.top(),HASHL) && Prio(S.top())>=Prio(hash(c))){
Suffix[sz++]=S.top();
S.pop();
}
S.push(hash(c));
}
}
}
if(Is_Num(str[ed-1]))
Suffix[sz++]=Num.x*Num.sign;
while(!S.empty()){
Suffix[sz++]=S.top();
S.pop();
}
double a,b,cur;
for(i=0;i<sz;i++){
cur=Suffix[i];
if(cur>-inf+10){
S.push(cur);
}
else{
b=S.top();
S.pop();
a=S.top();
S.pop();
if(Equal(HASHA,cur))
S.push(a+b);
else
if(Equal(HASHS,cur))
S.push(a-b);
else
if(Equal(HASHM,cur))
S.push(a*b);
else
{
if(Equal(b,0.0))
{
puts("错误:除数出现0!");
return ERRORX;
}
S.push(a/b);
}
}
}
delete []Suffix;
return S.top();
}

bool Calc::Cac(){
DelandLower(Exp);
int len=strlen(Exp);
if(!Check(Exp,len)) return 0;
Ans=GetV(Exp,0,len);
if(Equal(Ans,ERRORX))
return 0;
return 1;
}

　　

main.cpp

#include <iostream>
#include<stdlib.h>
#include"Calc.h"
using namespace std;

int main()
{
Calc c;
cout<<"	 smallCaculator"<<endl;
cout<<endl;
cout<<"Don't forget entering '=' at last"<<endl;
cout<<"for example: 1+5/10-sin(3.1415926/2)="<<endl;
cout<<"============================"<<endl;
while(1){
cout<<"Please enter the expression:"<<endl;
c.Input();
if(c.Cac()) c.Output();
system("pause");
cout<<"============================"<<endl;
}
return 0;
}