Question

用C++设计一简单的计算器模拟程序

它的功能是读入一个表达式，然后计算出它的值。运算符为“+”“*”，运算对象为整数，表达式里不出现括号，表达式以“；”结束。要尽可能短点的，考试急用！
一个表达式当然不止两个数，但我们笔试一题顶多半页纸答题空间不可能写得超过十几二十行吧？
5楼发几张运行截图来看看，运行没问题的话给你分！

Answer 1

注意：以下程序没有对错误的输入做判断，因此输入时要严格按照格式来输入，该程序可以测试任意多位，和在111位数之间的+和乘，当然还要做更大的计算，可以把数组改得更大既可，比如你可以输入1+2*2*2+2+3+2*3*4*5+2*2来测试结果是否正确。而且本程序可以计算任意位数长的加法和乘法计算，比如你可以使用1+1*1*1*1*1*1*1*1*2+3，来测试计算结果

void main()

{

int a[111]={0},m[111]={0};  //a用于接收输入的数字，m用于计算*之后的结果

char b[111];   //用于接收+和*字符。

int i=0,j=0,k=0;  //三个计数器

int s=0;  //计算结果存于此数。

 

while(1)   //此循环用于接收输入的数字和字符。

{  

scanf("%d",&a[i++]);  //数组a接收数字，因为整型数组a不接收字符，所以把字符留给后面的字符数组b来接收。

scanf("%c",&b[j++]);  //数组b接收字符

if(b[j-1]=='\n') break;  //如果数组b接收到回车字符，则表示输入完毕

}

int n=0;  //好像没有用到这个变量。

for(int j=0;j<i;j++)  //此循环用于做乘法和连乘运算

{

if(b[j]=='*'){m[k]=a[j]*a[j+1];a[j]=0;a[j+1]=0;k++;  //如果b[j]为乘法，则先计算乘法，也就是乘法的两个数是a[j]和a[j+1]

while(1){   //以下循环用于做连乘

if(b[j+1]=='*'){--k;m[k]=m[k]*a[j+2]; a[j+2]=0;k++;j++;}  //这个计算比较复杂，自已想想，是用于计算连乘的。

else break;}

}

else if(b[j+1]=='\n')break;

}

for(int j=0;j<i;j++)  //此运算用于做加法

s=s+a[j]+m[j];

printf("%d\n",s);

system("pause");

} 

运行结果，使用vs2005测试

Answer 2

不可能短的，涉及到优先级，这是求表达式的整个程序，包括除法，括号，和其他运算等，你看看吧，看明白了就知道怎么写了。
#include "iostream"
#include "math.h"
using namespace std;
# define MAX 15 //用数组实现栈，定义该数组的大小
template<class T>
class S_tack
{
public:
S_tack(); //构造函数
~S_tack(); //析构函数
T pop();
void push(T haha);
T data(); //返回栈顶元素，不执行栈指针跳动操作
private:
int top;
T *element;
};
template<class T>
S_tack<T>::S_tack()
{
element=new T[MAX];
top=0;
}
template<class T>
T S_tack<T>::pop()
{
if (top<0)
{
cout<<"Stack empty(1)";
exit(0);
}
else
return element[top--];
}
template<class T>
void S_tack<T>::push(T haha)
{
if (top>=15)
{
cout<<"Stack full 1";
exit(0);
}
element[++top]=haha;
}
template<class T>
S_tack<T>::~S_tack()
{
delete []element;
}
template<class T>
T S_tack<T>::data()
{
if (top<0)
{
cout<<"empty Stack(2)";
exit(0);
}
else
return element[top];
}

class Caculator
{
public:
void go();
bool isNun(char); //判断输入是否为数字
bool isOprator(char); //判断输入是否为操作符
void GetChar(char &ch);
int InStack(char); //栈内优先级
int OutStack(char); //栈外优先级
void doOprator(char); //执行二元操
private:
S_tack <double> NunStack;
S_tack <char> SingStack;
};
void Caculator::GetChar(char &ch)
{
cin>>ch;
while (ch==' '||ch=='\n')
{
cin>>ch;
}
}
void Caculator::go()
{
char ch,pri_char;
double nunber;
SingStack.push(';');
pri_char=';';
GetChar(ch);
while (SingStack.data()!=';'||ch!=';')
{
if (isNun(ch)||ch=='.')
{
cin.putback(ch);
cin>>nunber;
NunStack.push(nunber);
pri_char='0';
GetChar(ch);
}
else if (isOprator(ch))
{
if((pri_char==';'||pri_char=='(')&&(ch=='+'||ch=='-'))
NunStack.push(0);
else if (InStack(SingStack.data())<OutStack(ch))
{
SingStack.push(ch);
pri_char=ch;
GetChar(ch);
}
else if(InStack(SingStack.data())>OutStack(ch))
{
doOprator(SingStack.pop());
}
else if(InStack(SingStack.data())==OutStack(ch)&&ch==')')
{
SingStack.pop();
pri_char=')';
GetChar(ch);
};
}
else
{
cout<<"非法字符";
exit(0);
}

}
cout<<NunStack.data()<<endl;
}
bool Caculator::isNun(char haha)
{
switch(haha)
{
case '0':
return true;
break;
case '1':return true;
break;
case '2':
return true;
break;
case '3':
return true;
break;
case '4':
return true;
break;
case '5':
return true;
break;
case '6':
return true;
break;
case '7':
return true;
break;
case '8':
return true;
break;
case '9':
return true;
break;
case '-' :
if (OutStack('-')>InStack(SingStack.data()))
{
return true;
break;
}
default: return false;
}
}
bool Caculator::isOprator(char haha)
{
switch(haha)
{
case '+':
return true;
break;
case '-':
return true;
break;
case '*':
return true;
break;
case '/':
return true;
break;
case ';':
return true;
break;
case '(':
return true;
break;
case ')':
return true;
break;
case '^':
return true;
break;
case '%':
return true;
break;
default :
return false;
}
}
int Caculator::InStack(char op)
{
int result;
switch(op)
{
case ';':
result=0;
break;
case '(':
result=1;
break;
case '*':
case '/':
case '%':
result=5;
break;
case '^':
result=7;
break;
case '+':
case '-':
result=3;
break;
case ')':
result=8;
}
return result;
}
int Caculator::OutStack(char op)
{

int result;
switch(op)
{
case ';':
result=0;
break;
case '(':
result=8;
break;
case '^':
result=6;
break;
case '*':
case '/':
case '%':
result=4;
break;
case '+':
case '-':
result=2;
break;
case ')':
result=1;
}
return result;
}
void Caculator::doOprator(char haha)
{
double a,b;
a=NunStack.pop();
b=NunStack.pop();
switch(haha)
{
case '+':NunStack.push(a+b);
break;
case '-':NunStack.push(b-a);
break;
case '*':NunStack.push(a*b);
break;
case '/':
if (a==0)
{
cout<<"除数为零";
exit(0);
}
else
NunStack.push(b/a);
break;
case '^':NunStack.push(pow(b,a));
break;
case '%':NunStack.push((long)b%(long)a);
break;
}
}

int main()
{
Caculator h;
char haha='y';
while(haha=='y'||haha=='Y')
{
cout<<"请输入表达式，以;结束"<<endl;
h.go();
cout<<"Continue? Y or N"<<endl;
cin>>haha;
}

return 0;
}

Answer 3

#include<stdio.h>
int main(void)
{
int a=0;
int b=0;
int sum;
int ji;
printf("please input a and b:\n");
scanf("%d%d",&a,&b);
sum=a+b;
ji=a*b;
printf("a+b=%d;\n",sum);
printf("a*b=%d;\n",ji);
return 0;
}

用这个程序，开始后输入一个数然后按空格输入第二个数，按回车就会出现+和*的结果了。已经侧试过，可以运行。

Answer 4

这个可以了，够短！！
#include<iostream>
using namespace std;
int main()
{
char c1,c2;
int m,n;
cout<<"输入表达式:"<<endl;
while(1)
{
cin>>m>>c1>>n>>c2;
if(c2==';')
{
if(c1=='+')
cout<<m+n<<endl;
if(c1=='*')
cout<<m*n<<endl;
cout<<"再次输入表达式:"<<endl;
}
else
cout<<"输入有误！重新输入："<<endl;
}
return 0;
}

Answer 5

你的表达式只有一楼说的3+5，3*5这样的吗？会出现3+5*2这样要考虑运算优先级的表达式吗？