四则运算<3>

//李妍 2015.3.12
//四则运算新
#include<iostream>
#include<fstream>
#include<iomanip>
#include<cmath>
#include<vector>
#include<string>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
using namespace std;
#define random() (rand()%1000)
const int MAX=;

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

  /*输出模块*/
  class Output
  {
  public:
      Output()
      {
          result = ;
      }
      double getRes( double res )
      {
          result = res;
          return result;
      }

  private:
      double result;
  };

  /*计算用的存储结构*/
  template <class Type>
  class STACK{
     private:
         Type base[MAX];
         int Size;
     public:
         STACK()
         {
             Size=;
         };
         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<char>&, STACK<double>&, int& );
      double Calculate(char*, double& );   

  };
  bool jisuan::shuhanshu(char ch)
  {
      return ((ch>=''&&ch<='')||ch=='.')?true:false;
  }
  bool jisuan::fuhanshu(char ch)
 {
     return (ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='#')?true:false;
 }
 int jisuan::jckh(char ch)
 {
     if(ch=='(')
        return ;
     if(ch==')')
        return -;
     return ;
 }
 bool jisuan::jcxsd(char *ch)
 {
     int a=;
     for(int i=;i<strlen(ch);i++)
         if(ch[i]=='.')
             a++;
        if(a>)
             return false;
         return true;
 }
 int jisuan::pdyxj(char ch)          //符号的优先极别
 {
     switch(ch)
     {
     case '+':
         return ;
     case '-':
         return ;
     case '*':
         return ;
     case '/':
         return ;
     case '#':
         return ;
     default:
         return -;
     }
 }
 double jisuan::ToData(char* ch)   //将数字转化为数值
 {
     int i,j,sumn=;
     double sum=0.0;
     if(!jcxsd(ch)) return 0.0;
     for(i=;i<strlen(ch);i++)
     {
         if(ch[i]!='.')
             sumn=sumn*+(ch[i]-'');
         else break;
     }
     if(i<strlen(ch))
         for(j=i+;j<strlen(ch);j++)
             sum=sum*+(ch[j]-'');
     sum /= pow(10.0,(double)(strlen(ch)--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();
         }
         break;
     case '#':
         return ;
     default:ans=0.0;
         break;
     }
     return ans;
 }
 int jisuan::ppkh(char* buffer,int pos)     //利用栈找到匹配的括号
 {
     STACK<char> Temp;
     int i;
     for(i=pos;i<strlen(buffer);i++)
     {
         if(jckh(buffer[i])==)
             Temp.push('');
         if(jckh(buffer[i])==-)
         {
             Temp.pop();
             if(Temp.size()==) return i;
         }
     }
     return -;
 }
 void jisuan::Opr(STACK<char>& symbol,STACK<double>& data,int& mark)
 {
     double sum;
     while(symbol.size()!=)
     {
         char tem=symbol.pop();
         int temp=pdyxj(tem);
         symbol.push(tem);
         if(temp<mark)
             break;
         else{
             sum=Call(data.pop(),data.pop(),symbol.pop());
             data.push(sum);
         }
     }
 }
 double jisuan::Calculate(char* buffer,double& sum)   //字符串读入和各个函数调配
 {
     STACK<double> data;
     STACK<char> symbol;
     double ans;
     char temp[MAX];
     int ct=,mark=,tp=;
     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=;                         //读到非数字也非小数为止
             ans=ToData(temp);             //把读到的字符串转化为数
             data.push(ans);

             if(ct==strlen(buffer))        //已经独到字符串末尾
             {
                 mark=;
                 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[];int k=;          //如果都不是，则只能是括号
             while( jckh( buffer[ct] ) !=  && ct <= strlen(buffer) )
                 BF[k++] = buffer[ct++];
             BF[k]='\0';
             if(jckh(buffer[ct])==)       //一旦读到左括号，寻找它匹配的右括号
             {
                 int i,j;
                 char Temp[];
                 for(i=ct+,j=;i<ppkh(buffer,ct);i++,j++)
                     Temp[j]=buffer[i];     //把这对括号中的字符串存入Temp
                 Temp[j]='\0';
                 data.push(Calculate(Temp,sum)); 

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

string  i_s(int shuzi)
{
    int temp=abs(shuzi);
    char str[];
    itoa(temp,str,);
    string str1=str;
    return str1;
}

string zuhe (string str1,string str2,char x)
{
    string expression;
    expression=str1+x+str2;
    return expression;
}

 //是否有乘除法
char operator_random(int c1)
{
    char o;
    int c,c2;
    if(c1==)
    {
        c2=;
    }
    if(c1==)
    {
        c2=;
    }
    c= (rand() % )%c2;
    if (c == ) o = '+';
    else if (c == ) o = '-';
    else if (c == ) o = '*';
    else o = '/';
    return o;
}

void main()
{
    srand((unsigned)time(NULL));//设置时间种子 ，以使程序每次得到的结果都不同
    int mul_div,number,output_mode,value_range,num_1,num_2,plus_or_minus,jump,yushu,kuohao,score=;
    double answer=0.0,solution;
    string str_1,str_2,temp;
    char operator_r;
    char storage[];
    cout<<"    是否有乘除法？<0>没有   <1>有：";
    cin>>mul_div;
    cout<<"    有无括号？    <0>没有   <1>有：";
    cin>>kuohao;
    cout<<"    加减有无负数？<0>没有   <1>有：";
    cin>>plus_or_minus;
    cout<<"    除法有无余数？<0>没有   <1>有：";
    cin>>yushu;
    cout<<"    题目如何输出？<0>在文件中输出 ，<1>在此直接输出：";
    cin>>output_mode;
    cout<<"    请输入数值范围：";
    cin>>value_range;

    cout<<"    请输入题目的数量：";
    cin>>number;
    cout<<endl;

    string *expression=new string[number];//string expression[number];
    ofstream fout;
    if(output_mode==)
    {
        fout.open("yunsuan.txt");
        fout<<number<<"道随机四则运算："<<endl;
    }
    else
    {
        cout<<number<<"道随机四则运算："<<endl;
    }

    for (int i = ; i < number; i++)
    {
       num_1=random()%value_range+;
       num_2=random()%value_range+;
       int length;//运算式的长度
       int j=num_1-num_2;
       int x=num_1%num_2;
       operator_r=operator_random(mul_div);
       length=random()%+;
       str_1=i_s(num_1);
       str_2=i_s(num_2);
       expression[i]=zuhe(str_1,str_2,operator_r);
       if(length>)
       {
           for(length;length>;length --)
           {
               operator_r=operator_random(mul_div);
               str_1=expression[i];
               if(kuohao==)
               {
                   jump=random()%;
                   if(jump==)
                   {
                       str_1='('+str_1+')';
                   }
               }
               operator_r=operator_random(mul_div);
               num_2=random()%value_range+;
               str_2=i_s(num_2);
               jump=random()%;
               if (jump==)
               {
                   temp=str_1;
                   str_1=str_2;
                   str_2=temp;
               }
               expression[i]=zuhe(str_1,str_2,operator_r);

           }
       }
       if(output_mode==)
       {

           strcpy(storage,expression[i].c_str());

            cout.precision();            //设置精度为12

            Input in;
            jisuan cl;
            Output out;

            answer=out.getRes( cl.Calculate(storage,answer) ); //计算模块

            if(plus_or_minus== )
            {
                if(answer>)
                {
                    cout<<"    ("<<i+<<")"<<expression[i]<<"="<<endl;
                    cout<<"    输入结果：";
                    cin>>solution;
                    cout<<"    正确结果："<<answer<<endl;
                    if(answer==solution)
                    {
                        score++;
                        cout<<"    正确！！！"<<endl;
                        cout<<endl;
                    }
                    else
                    {
                        cout<<"    很遗憾，错误！"<<endl;
                        cout<<endl;
                    }
                }    //如果结果小于0
                else
                {
                    i=i-;
                }
            }
            else  //如果不要求加减无负数
            {
                cout<<"    ("<<i+<<")"<<expression[i]<<"="<<endl;
                    cout<<"    输入结果：";
                    cin>>solution;
                    cout<<"    正确结果："<<answer<<endl;
                    if(answer==solution)
                    {
                        score++;
                        cout<<"    正确！！！"<<endl;
                        cout<<endl;
                    }
                    else
                    {
                        cout<<"    很遗憾，错误！"<<endl;
                        cout<<endl;
                    }
            }
       }
       else
       {
           fout<<expression[i]<<"="<<endl;
       }
    }
    if(output_mode==)
    {
        cout<<"    得分："<<score<<endl;
        cout<<endl;
    }

    if(output_mode==)
    {
        fout.close();
    }
} 

结对编程伙伴：李妍 20133099 博客地址：http://www.cnblogs.com/liyan-luckygirl/

四则运算<3>要求新加的功能是可以输入答题，并判断对错，最后得出最终得分。

我们利用栈来实现对算式的运算，从符号优先级入手，利用栈匹配，字符串读入等完成运算，最终得到结果。