C++四则运算源程序代码

#include
#include
using namespace std;
const int MAX=1000;

/*欢迎模块*/
class Entry
{
public:
static void welcome()
{
cout<<" ===============================================\n"
<<" * 欢迎使用四则运算系统 *\n"
<<" * ============================================== *\n"
<<" * 作者：张丹丹 *\n"
<<" * *\n"
<<" * 学号：1109121101 *\n"
<<" * *\n"
<<" ===============================================\n\n\n"
<<"=================================进入主程序====================================\n\n"
<<"请输入表达式，回车结束：";
}
};

/*输入模块*/
class Input
{
public:
Input()
{
for( int i = 0;i < MAX;i++ )
Str_input[i] = '\0';
}
char Str_input[MAX];
void inStr()
{
cin>>Str_input;
}
};

/*输出模块*/
class Output
{
public:
Output()
{
result = 0;
}
void getRes( double res )
{
result = res;
}
void printRes()
{
cout<<"这个表达式的结果为："<}
private:
double result;
};

/*计算用的存储结构*/
template
class STACK{
private:
Type base[MAX];
int Size;
public:
STACK()
{
Size=0;
};
void push(Type a)
{
base[Size]=a;
Size++;
}
Type pop()
{
return base[--Size];
}
int size()
{return Size;}
};


/*计算的模块*/
class jisuan
{
public:
bool shuhanshu(char);
bool fuhanshu(char);
int jckh(char);
bool jcxsd(char *);
int pdyxj(char);
double ToData(char*);
double Call(double,double,char);
int ppkh(char* buffer,int pos);
void Opr( STACK&, STACK&, int& );
double Calculate(char*, double& );

};
bool jisuan::shuhanshu(char ch)
{
return ((ch>='0'&&ch<='9')||ch=='.')?true:false;
}
bool jisuan::fuhanshu(char ch)
{
return (ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='#')?true:false;
}
int jisuan::jckh(char ch)
{
if(ch=='(')
return 1;
if(ch==')')
return -1;
return 0;
}
b

ool jisuan::jcxsd(char *ch)
{
int a=0;
for(int i=0;iif(ch[i]=='.')
a++;
if(a>1)
return false;
return true;
}
int jisuan::pdyxj(char ch) //符号的优先极别
{
switch(ch)
{
case '+':
return 0;
case '-':
return 0;
case '*':
return 1;
case '/':
return 1;
case '#':
return 0;
default:
return -1;
}
}
double jisuan::ToData(char* ch) //将数字转化为数值
{
int i,j,sumn=0;
double sum=0.0;
if(!jcxsd(ch)) return 0.0;
for(i=0;i{
if(ch[i]!='.')
sumn=sumn*10+(ch[i]-'0');
else break;
}
if(ifor(j=i+1;jsum=sum*10+(ch[j]-'0');
sum /= pow(10.0,(double)(strlen(ch)-1-i));
return (sum+sumn);
}
double jisuan::Call(double sum,double data,char ch)
{
double ans=0.0;
switch(ch)
{
case '+':
ans=sum+data;
break;
case '-':
ans=sum-data;
break;
case '*':
ans=sum*data;
break;
case '/':
if( data != 0.0 )
ans=sum/data;
else
{
cout<<"程序出现除0错误，终止！\n";
system("pause");
exit(1);
}
break;
case '#':
return 0;
default:ans=0.0;
break;
}
return ans;
}
int jisuan::ppkh(char* buffer,int pos) //利用栈找到匹配的括号
{
STACK Temp;
int i;
for(i=pos;i{
if(jckh(buffer[i])==1)
Temp.push('0');
if(jckh(buffer[i])==-1)
{
Temp.pop();
if(Temp.size()==0) return i;
}
}
return -1;
}
void jisuan::Opr(STACK& symbol,STACK& data,int& mark)
{
double sum;
while(symbol.size()!=0)
{
char tem=symbol.pop();
int temp=pdyxj(tem);
symbol.push(tem);
if(tempbreak;
else{
sum=Call(data.pop(),data.pop(),symbol.pop());
data.push(sum);
}
}
}
double jisuan::Calculate(char* buffer,double& sum) //字符串读入和各个函数调配
{
STACK data;
STACK symbol;
double ans;
char temp[MAX];
int ct=0,mark=0,tp=0;
data.push(sum);
while(ct<=strlen(buffer))
{
if(shuhanshu(buffer[ct])) //如果是数字或小数点
{
while( ct < strlen(buffer) && shuhanshu(buffer[ct]) )
temp[tp++]=buffer[ct++];
temp[tp]='\0';
tp=0; //读到非数字

也非小数为止
ans=ToData(temp); //把读到的字符串转化为数
data.push(ans);

if(ct==strlen(buffer)) //已经独到字符串末尾
{
mark=0;
Opr(symbol,data,mark);
sum=data.pop();
return sum;
}
else{
int mark=pdyxj(buffer[ct]);
Opr(symbol,data,mark); //计算
}
}
else if(fuhanshu(buffer[ct])) //如果是运算符
symbol.push(buffer[ct++]); //运算符入symbol栈
else
{
char BF[100];int k=0; //如果都不是，则只能是括号
while( jckh( buffer[ct] ) != 1 && ct <= strlen(buffer) )
BF[k++] = buffer[ct++];
BF[k]='\0';
if(jckh(buffer[ct])==1) //一旦读到左括号，寻找它匹配的右括号
{
int i,j;
char Temp[100];
for(i=ct+1,j=0;iTemp[j]=buffer[i]; //把这对括号中的字符串存入Temp
Temp[j]='\0';
data.push(Calculate(Temp,sum));

ct+=(strlen(Temp)+1);
if(ct+1==strlen(buffer))
{
mark=0;
Opr(symbol,data,mark);
sum=data.pop();
return sum;
}
else
{
mark=pdyxj(buffer[ct+1]); //不是的话继续计算
Opr(symbol,data,mark);
}
ct++; //读入下一个字符
}
}
}
return 0.;
}


/*检查输入表达式正确性模块*/
class jcxsdStr
{
public:
static int jcxsd( char *str )
{
int i;
STACK Temp;
for( i = 0;i < strlen(str);i++ )
{
char t = str[i];
if( !( (int(str[i]) <= 57 && int(str[i]) >= 48) || str[i]=='(' || str[i]==')' || str[i]=='*'
|| str[i]=='+' || str[i]=='-' || str[i]=='/' || str[i]=='.'||str[i]=='#') ) //检测是否含有非法字符
return 2;
else if( str[i]=='(' )
Temp.push('0');
else if( str[i]==')' )
{
if( Temp.size()<=0 ) //检测括号是否匹配，右括号是否过多
return 1;
else
Temp.pop();
}
}
if( Temp.size()!=0 ) //检测括号是否匹配，左括号是否过多
ret

urn 1;
return 0;
}
};

int main()
{
Entry::welcome(); //欢迎模块
double sum=0.0;
cout.precision(12); //设置精度为12

Input in;
jisuan cl;
Output out;

while(1)
{
in.inStr(); //输入模块
int res = jcxsdStr::jcxsd(in.Str_input); //判断模块
if( res == 0 )
break;
else if( res == 1 )
cout<<"输入字符串括号不匹配，请重新输入：\n";
else if( res == 2 )
cout<<"输入字符串有非法字符，请重新输入：\n";
else
{}
}
out.getRes( cl.Calculate(in.Str_input,sum) ); //计算模块
out.printRes(); //输出模块
cout<<" ================================================\n"
<<" * * \n"
<<" * 非常感谢您对本程序的测试，再此提前预祝老师 *\n"
<<" * 新年快乐，度过一个愉快的假期！ * \n"
<<" * * \n"
<<" ================================================\n";

return 0;
}