[C++]算术计算器 简单计算+科学计算

help.txt

1.Simple Calculator可以解决加减乘除问题；输入形式如：1+2；（回车）

2.Scientific Calculator可以计算阶乘、开方、次方、粗略计算三角函数及反三角函数；具体格式见计算器提醒

3.Scientific Calculator可以存储计算结果。可以用()配合Ans1使用：1-(Ans1)；也可以直接是1-ans1；

按任意键: 返回上一界面

-------------------------------------------------------------------------------------------------------------------------------------------------------------------

主界面.cpp

#include <iostream>
#include "simple.h"
#include "calculate.h"
#include "info.h"

using namespace std;

int main()
{
char choice='1';
cout<<" ▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂"<<endl;
cout<<" ▏                       Simple Calculator                        ▏"<<endl;
cout<<" ▏                                       By:XiXi                  ▏"<<endl;
cout<<" ▏----------------------------------------------------------------▏"<<endl;
cout<<" ▏Please choose the kind of calculator:                           ▏"<<endl;
cout<<" ▏                       1.Simple Calculator                      ▏"<<endl;
cout<<" ▏                       2.Scientific Calculator                  ▏"<<endl;
cout<<" ▏                       3.help                                   ▏"<<endl;
cout<<" ▏                       4.add constant(添加你的常量)             ▏"<<endl;
cout<<" ▏                       5.show your constant                     ▏"<<endl;
cout<<" ▏                       0.exit                                   ▏"<<endl;
cout<<" ▏----------------------------------------------------------------▏"<<endl;
cout<<" ▏----------------------------------------------------------------▏"<<endl;
cout<<" ▏You can find more infomation in 'help.txt' in the folder~~      ▏"<<endl;
cout<<" ▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂"<<endl;
while(cin>>choice && choice!='0')
{
switch (choice)
{
case '1':
system("CLS");
scalculator();
break;
case '2':
system("CLS");
calculator();
break;
case '3':{
system("CLS");
read_info();
string s;
cin>>s;
system("CLS");}
break;
case '4':
system("CLS");
add_con();
break;
case '5':
system("CLS");
for(int i=0; i<sel.size();i++)
cout<<sel[i].name<<'='<<sel[i].vv<<endl;
break;
default:
system("CLS");
cout<<"invalid input!"<<endl;
break;
}
cout<<" ------------------------------------------------------------------"<<endl;
cout<<" ▏Please choose the kind of calculator:                           ▏"<<endl;
cout<<" ▏                       1.Simple Calculator                      ▏"<<endl;
cout<<" ▏                       2.Scientific Calculator                  ▏"<<endl;
cout<<" ▏                       3.help                                   ▏"<<endl;
cout<<" ▏                       4.add constant(添加你的常量)             ▏"<<endl;
cout<<" ▏                       5.show your constant                     ▏"<<endl;
cout<<" ▏                       0.exit                                   ▏"<<endl;
cout<<" ------------------------------------------------------------------"<<endl;
}

system("CLS");//clean the screen
cout<<"Thank you for your using!"<<endl;

char ch;
cin>>ch;

return 0;
}

--------------------------------------------------------------------------------------------------------------------------------------------------------------------

cal_class.h

#include <iostream>

using namespace std;

const double preci=0.000001;//精度
const int emax=1000;//表达式作为字符存入数组的最大长度
const double PI=3.1415926535;

//--------------------------------------------------------------------
double change(int n)
{
double x=1 ;
while(n>0){x *=10;n--;}
while(n<0){x /=10;n++;}
return x;
}

//---------------------------------------------------------------------
double to_dou(char *f,char *e=0)//将字符串转化为double型
{
long int z=0,x=0,i=0,c=0,m=0,fs=0;
char *hh=f;
double result=0.0;
//------------------------------------------------------------------
if(*f=='+')f++;
if(*f=='-'){fs=1;f++;}
//------------------------------------------------------------------
if(e==0)
{
int a=0;
while(*(f+a)!='\0')a++;
e=f+a-1;
}
while(f+m<=e){
if(*(f+m)=='/' || *(f+m)=='|')c=1;m++;
}
m=0;
//------------------------------------------------------------------
if(c==0)
{
while(f+m<=e){
if(i==0 && 47<*(f+m) && *(f+m)<58){z++;}
if(*(f+m)=='.'){i=1;}
if(i==1 && 47<*(f+m) && *(f+m)<58){x++;}
m++;
}

while(z>0)
{
result=result+ ((*f-48) * change(z-1));
z--;
f++;
}
f++,m=1;
while(x>=m){
result+=((*f-48)*change(-m));
f++,m++;
}
}
//------------------------------------------------------------------
else
{
double fz=0,fm=0;
m=0,x=0;
while(f+m<=e)
{
if(i==0 && 47<*(f+m) && *(f+m)<58){z++;}
if(*(f+m)=='/' || *(f+m)=='|'){i=1;}
if(i==1 && 47<*(f+m) && *(f+m)<58){x++;}
m++;
}
while(z>0)
{
fz += ((*f-48)*change(z-1));
z--,f++;
}
f++;
m=0;
while(x>0)
{
fm+=((*f-48)*change(x-1));
f++;
x--;
}
result = fz/fm;
}
//------------------------------------------------------------------
if(fs==1)result*=-1;

return result;
}
//-----------------------------------------------------------------
//-自定义变量的结构体
struct val
{
string name;//变量名
double vv;//变量值
};
//---------------------------------------------------------------------
vector <val> sel;//自定义变量的存储向量
//-------------------------------------------------------------------
void add_con()//添加自定义常量
{
cout<<"define as: PI=3.14;\nATTENTION:pi is different from PI"<<endl;
char input[emax],*readF,*readE;

label6:      cout<<"define(don't forget ';'):";
cin>>input;
readE=readF=input;
val v;

while(*readE != '='){v.name+=*readE;readE++;}
readE++;

readF=readE;
while(*readE != ';')
{
if(*readE>='0' && *readE<='9')readE++;
else {cout<<"WRONG DEFINE"<<endl;goto label7;}
}
v.vv=to_dou(readF,readE-1);
sel.push_back(v);
cout<<"add "<<v.name<<'='<<v.vv<<" success!"<<endl;

label7:      cout<<"\n______________________________________________________________"<<endl;
cout<<"press any key to continue...press Esc to exit:";cout.flush();
if ( getch() == 27)
{
system("CLS");
return;
}
else{
for(int i=0;i<49;i++)
cout<<"\b \b";
goto label6;
}
}
//--------------------------------------------------------------------
bool is_right(char * readF)//判断是否是规定的操作符或数
{
if((*readF >='0'&& *readF <='9') || (*readF >='a'&& *readF <='z')
||(*readF >='A'&& *readF <='Z')|| *readF=='^' || *readF=='!'|| *readF==')'|| *readF=='('
|| *readF=='+' ||*readF=='-' ||*readF=='*' || *readF=='/'
|| *readF=='%' ||*readF=='|')
return true;

for(int i=0;i<sel.size();i++)
if(*readF==sel[i].name[0])return true;

return false;
}

//------------------------------------------------------------------
struct elem//elements to save expression
{
double num;
char op;//operator
char *func;//function
char kind;//'N':num 'O':operator 'F':function
elem *last;//last one
elem *next;//next one
};

//--------------------------------------------------------------------
struct result_save//save as Ans1,Ans2,...
{
int no;
double result;
result_save *next;
};

//---------------------------------------------------------------------
int find_mdivisor(int n)//找出小于等于sqrt(n) 的最大约数
{
if(n==0)return 0;
int q, mn;
for(int i=1; i<=sqrt(n); i++)
{
q=i*i;
q=n%q;
if(q==0)mn=i;
}
return mn;
}

//--------------------------------------------------------

double fraction(double x,int m=1,bool js=1,bool FFM=0)//show in the form of fraction
{
double a=1.1, b=1, k=0;
if(m==0 && x==0){if(FFM==1)return 1;else return 0;}
while((int)a != a)
{
if(js>0 && a>=0 && (int)(a+preci)-a<preci && (int)(a+preci)-a>-preci)break;
if(js>0&&a<0 && (int)(a-preci)-a<preci && (int)(a-preci)-a>-preci)break;

a=x*b;
b++;
if(b>10000){k=1;break;}
}
b--;

if(FFM==1){return b;}
if(k==1){if(m!=2)cout<<x;return 2;}
else {
if(b!=1) {if(m!=2)cout<<a<<"|"<<b;return 1;}
else if(m!=2)cout<<a;
return 0;
}
}

//----------------------------------------------------------------------------
int root_mark(double x,int m=1,bool js=1)//show in the form of root_mark(根号)
{
double a=1.1,b=1,k=0;
int temp;
if(m==0&&x==0)return 1;
if(x==0) {if(m!=2)cout<<"0";return 1;}
if(x-1<preci && x-1>-preci)
{if(m!=2)cout<<"1";return 1;}
if(x<0) return 0;
while((int)a !=a)
{
if(js>0 && a>=0 && (int)(a+preci)-a<preci &&(int)(a+preci)-a>-preci)
{a=(double)(int)(a+preci);break;}
if(js&&a<0 && (int)(a-preci)-a<preci && (int)(a-preci)-a>-preci)
{a=(double)(int)(a+preci);break;}
a=x*b;
b++;
if(b>10000){k=1;break;}
}
b--;
if(k==1){if(m!=2)cout<<"√"<<x;return 3;}

temp=find_mdivisor((int)(a*b));
a=a*b/(temp*temp);
if(temp/b != 1){
if(m!=2)
{
if(a!=1)cout<<"(";
fraction(temp/b);
if(a!=1)cout<<")";}
}
if(a!=1)
{
if(m!=2)
cout<<"√"<<a;
return 2;
}
return 1;
}

---------------------------------------------------------------------------------------------------------------------------------------------

calculate.h

#include <conio.h>
#include <cmath>
#include "cal_class.h"
#include <vector>

int cal_simp(elem *parpF,elem *parpE,elem *parF=0,elem *parp=0)
{
elem *partemp,*partemp2,*partemp3,*partemp4;
double temp1=0,temp2=0,temp3=0;
bool i=0,i2=0;

partemp=parpF->next;
while(partemp->kind!=')')
{
if(partemp->op=='!')//处理阶乘
{   partemp2=partemp->last;
if(partemp2->kind!='N'){cout<<"\tINPUT ERROR:left number should be a number!"<<endl;return 0;}//!前一定要为'数'

temp1=temp2=1;//阶乘运算
while(temp1<=partemp2->num)
{temp2*=temp1;temp1++;}

partemp2->num=temp2;//将结果存入被阶乘元素栏
partemp2->next=partemp->next;
partemp4=partemp->next;
partemp4->last=partemp2;
free(partemp);//删除阶乘符号元素
partemp=partemp2;//连接乘符号元素前后两元素为相邻元素
}
partemp=partemp->next;
}

label5: partemp=parpE;
while(partemp->kind!='(')
{
if(partemp->op=='-')//处理负号
{
partemp2=partemp->last;
partemp3=partemp->next;
if(partemp3->kind=='F')//处理-sin30情况
{
partemp=partemp3;
i2=1;
goto label4;
}

if(partemp3->kind!='N'){cout<<"\t\tINPUT ERROR"<<endl;return 0;}
if(partemp2->kind=='N')
{   partemp3->num*=-1;
partemp->op='+';
}
if(partemp2->kind=='('||partemp2->kind=='F'||partemp2->kind=='O')
{
partemp3->num*=-1;
partemp2->next=partemp3;
partemp3->last=partemp2;
free(partemp);
partemp=partemp3;
}
}
partemp=partemp->last;
}

label3: partemp=parpF;
while(partemp->kind!=')')
{
if(partemp->op=='^')//次方
{
partemp2=partemp->last;
partemp3=partemp->next;
if(partemp3 ->kind =='F')
{
partemp=partemp3;
i=1;
goto label4;
}
if(partemp2->kind!='N' || partemp3->kind!='N'){cout<<"\t\tINPUT ERROR:\n^ left and right should be a number"<<endl;return 0;}//^前后都要为'数'
temp1=partemp2->num;
temp2=partemp3->num;
if(-1<temp2 && temp2<1 && temp2!=0 && temp1<0){cout<<"\t\tMATH ERROR"<<endl;return 0;}
temp3=pow(temp1,temp2);
partemp2->num=temp3;//保存入x

partemp4=partemp3->next;
partemp2->next=partemp4;
partemp4->last=partemp2;
free(partemp);free(partemp3);
partemp=partemp2;
}
partemp=partemp->next;
}

partemp=parpF;
while(partemp->kind!=')')
{
if(partemp->kind=='F')//处理函数运算
{
label4:         partemp2=partemp->next;
if(partemp2->kind!='N'){cout<<"\t\tINPUT ERROR"<<endl;return 0;}//'函数'后要为数
temp1=partemp2->num;
switch (*partemp->func)
{
case 'a':
switch (*(partemp->func+1))
{
case 's':
if(temp1<-1||temp1>1){cout<<"\t\tMATH ERROR"<<endl;return 0;}
temp2=asin(temp1)*180/PI;break;
case 'c':
temp2=acos(temp1)*180/PI;break;
case 't':
temp2=atan(temp1)*180/PI;break;
}
break;
case 'c':
temp2=cos(temp1*PI/180);
break;
case 'l':
switch (*(partemp->func+1))
{
case 'o':
if(temp1<0){cout<<"\t\tMATH ERROR"<<endl;return 0;}
temp2=log(temp1);
break;
case 'n':
if(temp1<0){cout<<"\t\tMATH ERROR"<<endl;return 0;}
temp2=log10(temp1);
break;
}
break;
case 's':
switch (*(partemp->func+1))
{
case 'i':
temp2=sin(temp1*PI/180);break;
case 'q':
if(temp1<0){cout<<"\t\tMATH ERROR"<<endl;return 0;}
temp2=sqrt(temp1);
break;
}
break;
case 't':
temp2=tan(temp1*PI/180);
break;//tan
default:
cout<<"\t\tINPUT ERROR"<<endl;return 0;
}

partemp2->num=temp2;//将结果放在函数的参数项中
partemp4=partemp->last;
partemp4->next=partemp2;
partemp2->last=partemp4;
free(partemp);//删'函数'元素项
partemp=partemp4;
if(i==1){i=0;goto label3;}//对应上"处理5 ^ sin 30这种情况"让其变为5 ^ 0.5
if(i2==1){i2=0;goto label5;}//对应上 处理- sin 30这种情况 让其变为- 0.5
}
partemp=partemp->next;
}

partemp=parpF;
while(partemp->kind!=')')
{
if(partemp->op=='*')//处理乘法运算
{
partemp2=partemp->last;
partemp3=partemp->next;
if(partemp2->kind!='N'||partemp3->kind!='N'){cout<<"\t\tINPUT ERROR"<<endl;return 0;}//*前后都要为'数'

temp1=partemp2->num*partemp3->num;
partemp2->num=temp1;
partemp4=partemp3->next;
partemp2->next=partemp4;
partemp4->last=partemp2;
free(partemp);free(partemp3);
partemp=partemp2;
}

if(partemp->op=='/')//处理除法运算
{
partemp2=partemp->last;
partemp3=partemp->next;
if(partemp2->kind!='N'||partemp3->kind!='N'){cout<<"\t\tINPUT ERROR"<<endl;return 0;}//*前后都要为'数'
if(partemp3->num==0){cout<<"\t\tMATH ERROR"<<endl;return 0;}//除数不为0
temp1=partemp2->num/partemp3->num;
partemp2->num=temp1;
partemp4=partemp3->next;
partemp2->next=partemp4;
partemp4->last=partemp2;
free(partemp);free(partemp3);
partemp=partemp2;
}
partemp=partemp->next;
}

partemp=parpF;
while(partemp->kind!=')')
{    if(partemp->op=='+')//处理加法运算
{   partemp2=partemp->last;
partemp3=partemp->next;
if(partemp2->kind!='N'||partemp3->kind!='N'){cout<<"\t\tINPUT ERROR"<<endl;return 0;}//*前后都要为'数'
temp1=partemp2->num+partemp3->num;
partemp2->num=temp1;
partemp4=partemp3->next;
partemp2->next=partemp4;
partemp4->last=partemp2;
free(partemp);free(partemp3);
partemp=partemp2;
}
partemp=partemp->next;
}

partemp=parpF->next;
partemp2=partemp->next;
if(parpF->num==125&&parpE->num==-125){return 2;}//最外括号
else{
if(parpE->num ==-125)//反括号为最外括号 但正括号不为
{
partemp2=parpF->last;
partemp2->next=partemp;
partemp->last=partemp2;
free(parpF);
return 1;
}
partemp2=parpE->next;
partemp2->last=partemp;
partemp->next=partemp2;
free(parpE);
partemp3=parpF->last;
partemp3->next=partemp;
partemp->last=partemp3;
free(parpF);
return 1;
}
}

double cal(int k,result_save *p)
{
char input[emax],*readF,*readE;//save expression ,and the first and the end
int i=0;
elem *parF,*parE,*parp;//表达式首尾部分
result_save *MP;
cout<<"Expression:";cout.flush();
cin>>input;

parF=parE=parp=new elem;//建立一个简单的双向链表以存储表达式
parF->kind='(';//let first elem to be '('
parE->num=125;//125~first,-125~end
parE->op='\0';
parE->func="\0\0\0\0\0";
parE->next=new elem;
parp=parE;
parE=parE->next;
parE->last=parp;
parE->num=0;
parE->op='\0';
parE->func="\0\0\0\0\0";

{
int lp=0;//记录未配对的左括号 '('数
readF=input;
while(*readF!='\0')
{

//----自定义常量----------------------------------------------
label1:    for(int i=0; i<sel.size(); i++)
{
int j;
if(*readF == sel[i].name[0])
{
readE=readF;
for(j=0;j<sel[i].name.length();j++,readE++)
if(*readE != sel[i].name[j])break;

if(j<sel[i].name.length())readE=readF;//如果不是就退回
else
{
parE->num=sel[i].vv;//提取
parE->kind='N';
parE->next=new elem;
parp=parE;
parE=parE->next;
parE->last=parp;
parE->num=0;
parE->op='\0';
parE->func="\0\0\0\0\0";
readF=readE;
}
}
}

//-是调用已有结果 ------------------------------------------------------------
if(tolower(*readF)=='a' && tolower(*(readF+1))=='n' && tolower(*(readF+2))=='s')
{
int reorder,i=1;
readF+=3;readE=readF;
while('0'<=*readE && *readE<='9')readE++;
readE--;
parE->kind='N';
reorder=(int)to_dou(readF,readE);
if(reorder>=(k-1)){cout<<"\t\tCANNOT FOUND THE MEMORIED NUMBER"<<endl;return 0;}
MP=p;
while(i<reorder){MP=MP->next;i++;}
parE->num=MP->result;//提取记忆数
parE->next=new elem;
parp=parE;
parE=parE->next;
parE->last=parp;
parE->num=0;
parE->op='\0';
parE->func="\0\0\0\0\0";
readF=readE;readF++;
}

//----------------------------------------------------------------------------
else if(is_right(readF)==0){cout<<"\t\tUNKNOW CHAR"<<endl;return 0;}//判断不是可识别的字符

//--数字--------------------------------------------------------------
else if(('0' <=*readF && *readF<='9'))
{
bool i=0;//是否有此数标识
readE=readF;
while (true)//确定此数尾数
{
if(('0'>*readE || *readE>'9') &&*readE!='|' &&*readE!='.')break;//非数的时候结束
if(readE=='\0'){readE--;break;}//超出了算式字符串时结束
readE++;
}
readE--;//退回到数字的最后一位
parE->num=to_dou(readF,readE);
parE->kind='N';
parE->next=new elem;
parp=parE;
parE=parE->next;
parE->last=parp;
parE->num=0;
parE->op='\0';
parE->func="\0\0\0\0\0";

while(('0'<=*readF && *readF<='9') || *readF=='|' ||*readF=='.')readF++;

if((64<*readF && *readF<91) || (96<*readF&&*readF<123) || *readF=='(')//补充省略的*
{
parE->op='*';
parE->kind='O';

parE->next=new elem;
parp=parE;
parE=parE->next;
parE->last=parp;
parE->num=0;
parE->op='\0';
parE->func="\0\0\0\0\0";
}
}

//----运算符-------------------------------------------------------------------
else if(*readF=='+' || *readF=='-' || *readF=='*' || *readF=='/' || *readF=='^' ||*readF=='!')
{
parE->op=*readF;
parE->kind='O';
parE->next=new elem;
parp=parE;
parE=parE->next;
parE->last=parp;
parE->num=0;
parE->op='\0';
parE->func="\0\0\0\0\0";
readF++;
}

//---函数sin...---------------------------------------------
else if((64<*readF && *readF<91)||(96<*readF&&*readF<123))
{
if(tolower(*readF)=='a' && tolower(*(readF+1))=='n' && tolower(*(readF+2))=='s')
goto label1;
switch (*readF)
{
case 'a':
switch (*(readF+1))
{
case 's':
parE->func="asin";
break;
case 'c':
parE->func="acos";
break;
case 't':
parE->func="atan";
break;
default:
cout<<"\t\tINPUT ERROR"<<endl;return 0;
}break;
case 'c':
parE->func="cos";break;
case 'l':
switch (*(readF+1))
{
case 'o':
parE->func="log";
break;
case 'n':
parE->func="ln";
break;
default:
cout<<"\t\tINPUT ERROR"<<endl;
return 0;
}break;
case 's':
switch (*(readF+1))
{
case 'i':
parE->func="sin";
break;//sin
case 'q':
parE->func="sqrt";
break;//sqrt
default:
cout<<"\t\tINPUT ERROR"<<endl;
return 0;
}break;
case 't':
parE->func="tan";
break;//tan
default:
cout<<"\t\tINPUT ERROR"<<endl;
return 0;
}
parE->kind='F';
parE->next=new elem;
parp=parE;
parE=parE->next;
parE->last=parp;
parE->num=0;
parE->op='\0';
parE->func="\0\0\0\0\0";

while((64<*readF&&*readF<91)||(96<*readF&&*readF<123))readF++;
}
//---括号----------------------------------------------------
else if(*readF == '(')
{
parE->kind='(';
lp++;
parE->next=new elem;
parp=parE;
parE=parE->next;
parE->last=parp;
parE->num=0;
parE->op='\0';
parE->func="\0\0\0\0\0";
readF++;
}
else if(*readF ==')')
{
if(lp==0){cout<<"\t\tMISS  '('"<<endl;return 0;}
parE->kind=')';
lp--;
parE->next=new elem;
parp=parE;
parE=parE->next;
parE->last=parp;
parE->num=0;
parE->op='\0';
parE->func="\0\0\0\0\0";
readF++;
}

if(lp<0){cout<<"\t\tMISS  '('"<<endl;return 0;}//反括号数量多与正括号
parE->kind=')';
parE->num=-125;
parE->next=NULL;
}

//计算
elem *parp2,*parp3;
int par_re;
label2: parp=parF;
parp3=parE;//用parp2,parp3括出最中间的两个对应正反括号
for( ; parp->next!=NULL; parp=parp->next)
{
if(parp->kind=='(')parp2=parp;
if(parp->kind==')'){parp3=parp;break;}
}

par_re=cal_simp(parp2,parp3,parF);//先计算括号内结果
if(par_re==0){return 0;}//输入有错误
//输出
parp=parF->next;

cout<<"Ans"<<k-1<<"=";
while( parp->kind !=')' || parp->num!=-125)
{
if(parp->kind=='(')cout<<'(';
if(parp->kind==')')cout<<')';
if(parp->kind =='N')
{
if(parp->num <= 0)
{
fraction(parp->num);
parp=parp->next;
continue;
}
if(root_mark(parp->num*parp->num,2) ==3)
{
cout.flush();
cout<<parp->num;
cout.flush();
}
else root_mark(parp->num*parp->num);
}
if(parp->kind=='O')cout<<parp->op;
if(parp->kind=='F')cout<<parp->func;
parp=parp->next;
}
cout<<endl;
if(par_re==1)goto label2;//还有括号
parp=parF->next;
}

return parp->num;
}

void delete_all(result_save * head)
{
result_save * p=head;
for( ;head != NULL; )
{
head=head->next;
delete p;
p=head;
}
}

int calculator()
{
cout<<" ▏------------------------------------------------------------------------▏"<<endl;
cout<<" ▏①input your expression,then press 'Enter';                             ▏"<<endl;
cout<<" ▏②we can do with:sin asin cos acos tan atan ln log sqrt (asin:arcsin)   ▏"<<endl;
cout<<" ▏                 !   ()    ^:y^x为y的x次方                              ▏"<<endl;
cout<<" ▏③we can do with fraction:1/2:1|2                                       ▏"<<endl;
cout<<" ▏④we can record the results,you can input Ans1,Ans2...to find           ▏"<<endl;
cout<<" ▏   and you can use it with '('')':1-(Ans1)                              ▏"<<endl;
cout<<" ▏------------------------------------------------------------------------▏"<<endl;

int k=1;//用来标识Ans的下标
result_save *p1,*p2;
p1=p2=new result_save;//开一个新结果记录，并让p1,p2指向同一空间
p1->no=k;k++;//Ans(k)

while(true)
{
p1->result=cal(k,p2);//start a calculation

cout<<"\n______________________________________________________________"<<endl;
cout<<"press any key to continue...press Esc to exit:";cout.flush();
if ( getch() == 27)
{
system("CLS");
return 0;
}
else{
for(int i=0;i<49;i++)
cout<<"\b \b";
}

p1->next=new result_save;
p1=p1->next;
p1->no=k;k++;
p1->next=NULL;
}

delete_all(p2);
return 0;
}

--------------------------------------------------------------------------------------------------------------------------

info.h

//读取帮助文件
#include <fstream>
#include <iostream>

using namespace std;

const int l=100;//每一行的长度

void read_info()
{
ifstream ios("help.txt");
char s[l];//用于读取文件中的一行

for(int j=0;j<l;j++)
s[j]='\t';
while( ios.getline(s,l))
{
for(int i=0;i<l;i++)
{
if(s[i]!='\t')
cout<<s[i];
}
cout<<endl;
for(int j=0;j<l;j++)
s[j]='\t';
}
}

------------------------------------------------------------------------------------------------------------------------------------

simple.h

#include <iostream>
#include <string>
#include <vector>

using namespace std;

const char number='8';//we use const '8' to represent a number
const char quit='q';  //t.kind==quit means that t is a quit token
const char print=';'; //t.kind==print means that t is a print token
const string prompt="Expression:";
const string result="=";//used to indicate that what follows is a result

class Bad_area{};

void error(string s)
{
cout<<s<<endl;
throw Bad_area();
}

//定义项向量
class Token{
public:
char kind;
double value;

Token(char ch)
:kind(ch),value(0){}
Token(char ch,double val)
:kind(ch),value(val){}
};

//定义单词流
class Token_stream
{
public:
Token_stream();
Token get();
void putback(Token t);
void ignore(char c);
private:
bool full;
Token buffer;
};

Token_stream::Token_stream()
:full(false), buffer(0)
{
}

void Token_stream::putback(Token t)
{
if (full)
error("putback() into a full buffer");
buffer = t;
full = true;
}

Token Token_stream::get()
{
if (full){
full=false;
return buffer;
}
char ch;
cin >> ch;

switch (ch) {
case print:
case quit:
case '(': case ')': case '+': case '-': case '*': case '/':case'%':
return Token(ch);
case '.':
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
{
cin.putback(ch);
double val;
cin >> val;
return Token(number,val);
}
default:
error("Bad token");
}
}

void Token_stream::ignore(char c)//c represents the kind of Token
{
//first look in buffer
if(full&&c==buffer.kind){
full=false;
return;
}
full=false;
//now search input
char ch='0';
while(cin>>ch)
if(ch==c)return;
}

double expression(Token_stream & ts2);

double primary(Token_stream & ts4)
{
Token t=ts4.get();
switch(t.kind){
case'(':                          //handle '('expression')'
{
double d=expression(ts4);
t=ts4.get();
if(t.kind!=')')
error("')'expected");
return d;
}
case number:
return t.value;
case'-':                        //handle'-'primary e.g.(-1)+2
return 0-primary(ts4);
case'+':
return 0+primary(ts4);
default:
error("primary expected! Please enter ';' to go on:");
}
}

double term(Token_stream & ts3)
{
double left=primary(ts3);
Token t=ts3.get();

while(true){
switch(t.kind){
case'*':
left*=primary(ts3);
t=ts3.get();
break;
case'/':
if(primary(ts3)==0)error("/ divide by zero.");
else{
left/=primary(ts3);
t=ts3.get();}
break;
case'%':{
double d=primary(ts3);
int i1=int(left);
if(i1!=left) error("left-hand operand of % not int");
int i2=int(d);
if(i2!=d) error("right-hand operand of % not int");
if(i2==0) error("%divide by zero");
left=i1%i2;
t=ts3.get();
break;
}
default:
ts3.putback(t);
return left;
}
}
}

double expression(Token_stream & ts2)
{
double left=term(ts2);
Token t=ts2.get();

while(true){
switch(t.kind){
case'+':
left+=term(ts2);
t=ts2.get();
break;
case'-':
left-=term(ts2);
t=ts2.get();
break;
default:
ts2.putback(t);
return left;
}
}
}

/*int keep_window_open(char ch)
{
if(ch=='~'){
cout<<"Calculator closed!\nPlease enter the character ~ to close the window"<<endl;
char ch;
while(cin>>ch){
if(ch=='~')
return 1;
}
}
else{
cout<<"Calculator closed!\nPlease enter the character'q' to close the window"<<endl;
char ok;
while(cin>>ok){
if(ok=='q')
return 2;
}
}
}*/

void clean_up_mess(Token_stream & ts5)
{
ts5.ignore(print);
}

void calculate(Token_stream ts1)
{
while (cin)
try {
cout<<prompt;

Token t = ts1.get();

while(t.kind==print)
t=ts1.get();
if (t.kind == quit) return;
ts1.putback(t);
cout <<result<<expression(ts1)<<endl;
}

catch(Bad_area){
clean_up_mess(ts1);
}
}

int scalculator()
{
cout<<"************************"<<endl;
cout<<"|  Simple Calculator    |"<<endl;
cout<<"************************"<<endl;

cout<<"Please enter expression(we can handle +、-、*、/、%)："<<endl;
cout<<"add "<<print<<" to end expression(e.g. （1+2）*3;):"<<endl;
cout<<"add "<<quit<<" to end calculating"<<endl;

Token_stream ts;

try{
calculate(ts);
system("CLS");//clean the screen
return 0;
}

catch(...){
cout<<"exception"<<endl;
system("CLS");
return 2;
}
}