c++四则运算代码

 //Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->  //一个能处理四则运算的程序，实现语言C++，支持嵌套括号，可以处理实数，源码见下面：
  #include<iostream>
  #include <stdio.h>
  #include <string.h>

  #include<cmath>
  using namespace std;
  const int MAX=;

  class Input
  {
  public:
      Input()
      {
          for( int i = ;i < MAX;i++ )
              Str_input[i] = '\0';
      }
      char Str_input[MAX];
  }in;

  class Output
  {
  public:
      Output()
      {
          result = ;
      }
      void getRes( double res )
      {
          result = res;
      }
      double printRes()
      {
 //         cout<<"这个表达式的结果为："<<result<<endl;
    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 Calculate_Cla
  {
  public:
      bool IsData(char);
      bool IsSym(char);
      int IsPar(char);
      bool Check(char *);
      int setPri(char);                 //判断符号的优先极别
      double ToData(char*);               //把字符串转化为数值
      double Call(double,double,char);    //具体按符号计算
      int GetMatch(char* buffer,int pos); //利用栈找到匹配的括号
      void Opr( STACK<char>&, STACK<double>&, int& ); //利用栈计算
      double Calculate(char*, double& );   //字符串的读入及调配

  };
  bool Calculate_Cla::IsData(char ch)      //判断输入计算的数字是否为0-9  添加科学计数法e
  {
      return ((ch>=''&&ch<='')||ch=='.'||ch=='e')?true:false;//添加科学计数法e
  }
  bool Calculate_Cla::IsSym(char ch)      //判断是否输入非法运算符
  {
      return (ch=='+'||ch=='-'||ch=='*'||ch=='/')?true:false;
  }
  int Calculate_Cla::IsPar(char ch)  //判断是否'()'
  {
      if(ch=='(')
         return ;
      if(ch==')')
         return -;
      return ;
  }
  bool Calculate_Cla::Check(char *ch)//检验小数点个数，>1报错 l
  {
      int a=;
      for(int i=;i<strlen(ch);i++)
          if(ch[i]=='.')
              a++;
          if(a>)
              return false;
          return true;
  }
  int Calculate_Cla::setPri(char ch)          //符号的优先极别
  {
      switch(ch)
      {
      case '+':
          return ;
      case '-':
          return ;
      case '*':
          return ;
      case '/':
          return ;
      default:
          return -;
      }
  }
  double Calculate_Cla::ToData(char* ch)   //将数字转化为数值
  {
      int i,j,k,sumn=;
      double sum=0.0,p=0.0,q=0.0;
   int summ=;//科学计数法所表示的数据e
      if(!Check(ch)) return 0.0;
      for(i=;i<strlen(ch);i++)             //读入整数部分
      {
          if(ch[i]!='.')
              sumn=sumn*+(ch[i]-'');
          else break;
      }
   if(strchr(ch, 'e')!=NULL)//判断是否为科学计数法e
   {/////////
   if(i<strlen(ch))
        for(j=i+;j<strlen(ch);j++)        //小数部分，到e为止
     {
      if(ch[j]!='e')
           sum=sum*+(ch[j]-'');
      else break;
     }
   sum /= pow(10.0,(double)(strlen(ch)--i)); //有错
   if(ch[j]=='e'&&j<strlen(ch))
   {
 //    if(ch[j]!='\0')      //科学计数法部分e
     for(k=j+;k<=j+;k++)
        summ=summ*+(ch[k]-'');// ch[j]的ascii码减去0的ascii码
     if(ch[j+]=='-')
     {
      double p=(sum+sumn)/pow(,summ);
      return ((sum+sumn)/pow(,summ));                    //返回值
     }
     if(ch[j+]=='+')
     {
      double q=(sum+sumn)*pow(,summ);
       return ((sum+sumn)*pow(,summ));
     }
    }
   }/////////////////
   else if(strchr(ch, 'e')==NULL)//如果不含科学计数法e
   {
   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 Calculate_Cla::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;
      default:ans=0.0;
          break;
      }
      return ans;
  }
  int Calculate_Cla::GetMatch(char* buffer,int pos)     //利用栈找到匹配的括号
  {
      STACK<char> Temp;
      int i;
      for(i=pos;i<strlen(buffer);i++)
      {
          if(IsPar(buffer[i])==)//左括号l
              Temp.push('');
          if(IsPar(buffer[i])==-)//右括号l
          {
              Temp.pop();//出栈l
              if(Temp.size()==) return i;
          }
      }
      return -;
  }
  void Calculate_Cla::Opr(STACK<char>& symbol,STACK<double>& data,int& mark)//运算符操作l
  {
      double sum;
      while(symbol.size()!=)//运算符栈大小不为0，l
      {
          char tem=symbol.pop();//出栈l
          int temp=setPri(tem);//优先级l
          symbol.push(tem);//入栈l
          if(temp<mark)
              break;
          else
    {
              sum=Call(data.pop(),data.pop(),symbol.pop());
              data.push(sum);
          }
      }
  }
  double Calculate_Cla::Calculate(char* buffer,double& sum)   //字符串读入和各个函数调配
  {
      STACK<double> data;
      STACK<char> symbol;
      double ans;
      char temp[MAX];
      int ct=,mark=,tp=;
      data.push(sum);//入栈l
      while(ct<=strlen(buffer))
      {
          if(IsData(buffer[ct]))            //如果是数字或小数点
          {
              while( ct < strlen(buffer) && IsData(buffer[ct]) )
     {
      temp[tp++]=buffer[ct++];
     }
    if(temp[tp-]=='e')
    {
     for(int k=;k<=;k++)
      temp[tp++]=buffer[ct++];
     temp[tp]='\0';
    }
    else temp[tp]='\0';
              tp=;                         //读到非数字也非小数为止
              ans=ToData(temp);             //把读到的字符串转化为数
              data.push(ans);      //将数字存入栈中l

              if(ct==strlen(buffer))        //已经独到字符串末尾
              {
                  mark=;
                  Opr(symbol,data,mark);    //计算
                  sum=data.pop();           //此时data栈中还剩一个数据，即是结果
                  return sum;               //返回结果
              }
              else
     {
                  int mark=setPri(buffer[ct]);
                  Opr(symbol,data,mark);     //计算
              }
          }
          else if(IsSym(buffer[ct])&&buffer[ct-]!='e')         //如果是运算符且不为指数部分
       symbol.push(buffer[ct++]);     //运算符入symbol栈
          else
          {
              char BF[];int k=;          //如果都不是，则只能是括号
              while( IsPar( buffer[ct] )!= && ct <= strlen(buffer) )
                  BF[k++] = buffer[ct++];
              BF[k]='\0';
              if(IsPar(buffer[ct])==)       //一旦读到左括号，寻找它匹配的右括号
              {
                  int i,j;
                  char Temp[];
                  for(i=ct+,j=;i<GetMatch(buffer,ct);i++,j++)
                      Temp[j]=buffer[i];     //把这对括号中的字符串存入Temp
                  Temp[j]='\0';
                  data.push(Calculate(Temp,sum)); //递归调用Calculate直到没有括号
                             //然后开始计算，值层层返回最后将最终结果放入data栈
                  ct+=(strlen(Temp)+);       //跳过已经处理完的字符
                  if(ct+==strlen(buffer))    //这里考虑字符串以括号结尾的情况
                  {
                      mark=;
                      Opr(symbol,data,mark);
                      sum=data.pop();
                      return sum;
                  }
                  else
                  {
                      mark=setPri(buffer[ct+]); //不是的话继续计算
                      Opr(symbol,data,mark);
                  }
                  ct++;                           //读入下一个字符
              }
          }
      }
      return .;
  }

  class CheckStr
  {
  public:
      static int check( char *str )
      {
          int i;
          STACK<char> Temp;
          for( i = ;i < strlen(str);i++ )
          {
              char t = str[i];
              if( !(  (int(str[i]) <=  && int(str[i]) >= ) || str[i]=='(' || str[i]==')' || str[i]=='*'
                  || str[i]=='+' || str[i]=='-' || str[i]=='/' || str[i]=='.'||str[i]=='e')   )       //检测是否含有非法字符 添加科学计数法e
                  return ;
              else if( str[i]=='(' )
                  Temp.push('');
              else if( str[i]==')' )
              {
                  if( Temp.size()<= )                                      //检测括号是否匹配，右括号是否过多
                      return ;
                  else
                      Temp.pop();
              }
          }
          if( Temp.size()!= )                                                //检测括号是否匹配，左括号是否过多
              return ;
          return ;
      }
  };

 double function(char*Str_input)//Str_input代入equation[][]
  {
      double sum=0.0;
      cout.precision();

      Calculate_Cla cl;
      Output out;

      while()
      {
    Str_input;//输入模块
          int res = CheckStr::check(Str_input); //判断模块 in.Str_input
          if( res ==  )
              break;
          else if( res ==  )
              cout<<"输入字符串括号不匹配，请重新输入：\n";
          else if( res ==  )
              cout<<"输入字符串有非法字符，请重新输入：\n";
          else
          {}
      }
      out.getRes( cl.Calculate(Str_input,sum) ); //计算模块
 //   out.printRes();                               //输出模块
      system("pause");
 //     return 0;
   return out.printRes();
  }
  void main()
  {
   char *fun="12.3e-001+(-4.56e+002)";
 //  char *fun="1.23+(-456)";
   double C=function(fun);
   cout<<"这个表达式的结果为："<<C<<endl;
  }