四则运算3

    实验思路： 利用四则运算2构造的式子和数据结构中栈的应用求表达式的值计算结果。

      1.建立并初始化OPTR和OPND栈，分别存放符号和数字。

      2.依次取表达式的每个值和符号，执行3-5，知道求出最后的值。

      3.去除optr栈顶元素，与都入的进行比较，当读入#时，求解完毕。

      4.栈顶元素是数字，压opnd栈

      5.如果是符号，将符号与optr栈顶元素进行比较，如果小于，将符号压入optr，如果大于，optr出栈，做相应运算，然后将计算结果压入opnd栈，如果等于，optr栈顶元素为（，读入字符为），这时候optr出栈，继续读取下一个字符。

      根据这个算法，我们也遇到了很多问题：

      第一，我们将其调试，成功的第一步是能够运算10以内的四则运算，但是若两位数呢。

      第二，我们将程序进行改进，把char类型换为double类型，然后建立了三个数组，double a[],char b[],int clu[],分别存放操作数，运算符和对应位置应该是什么(clu[0]=1,表示第一个应该是一个数，clu[1]=2,表示此时应该为一个符号)，这 样就能是操作数不再局限于一位数了。

      第三，程序可以了以后，我们又将程序编程一个字符串，将字符串分开存到三个数组里，在进行运算。根据clu数组的值，在数组a[],b[]进行取值，并运算。

程序代码：

/*
结对编程《四则运算》
于磊  20133078
李萌  20133079 */
#include <iostream>
#include <string>
#include <ctime>
#define N 50
using namespace std;
void Operands_1()  /*产生操作数 （-9 -- 9）除0*/
{
    while(int f=1)  
    {
        int Oper=rand()%19-9;
        if(Oper>0)             /*没有0*/
        {
            cout<<Oper;
            break;
        }
        if(Oper<0)
        {
            cout<<"("<<Oper<<")";
            break;
        }
    }
}
void Operands_2()/*-9到9  有0*/
{
    while(int f=1)  /*产生操作数 （-9 -- 9）*/
    {
        int Oper=rand()%19-9;
        if(Oper>=0)/*有0*/
        {
            cout<<Oper;
            break;
        }
        else
        {
            cout<<"("<<Oper<<")";
            break;
        }
    }
}
int Operands_3() /*0-9*/
{
    int Operand=rand()%9+1;
    return Operand;
}
string Operands_4()
{
    string s="";
    int Operand=rand()%99+1;
    if(Operand<10)
    {
        s+=Operand+48;
    }
    else
    {
        s+=Operand/10+48;
        s+=Operand%10+48;
    }
    return s;
}
void Operator_1(string &formula)/*随机产生运算符   有乘除*/
{
    int f=rand()%4;
    if(f==0) 
    {
        formula+="+";
    }
    if(f==1)
    {
        formula+="-";
    }
    if(f==2)
    {
        formula+="*";
    }
    if(f==3)
    {
        formula+="/";
    }
}
void Operator_2(string &formula)/*随机产生运算符   无乘除*/
{
    int f=rand()%2;
    if(f==0) 
    {
        formula+="+";
    }
    if(f==1)
    {
        formula+="-";
    }
}
int Bracket_l(int left,string &formula) /*随机产生左括号*/
{
    int f=rand()%3;
    if(f<2)
    {
        return left;
    }
    if(f==2)
    {
        formula+="(";
        return left+1;
    }
    return 0;
}
int Bracket_r(int right,string &formula) /*随机产生右括号*/
{
    int r=rand()%5;
    if(r==0)
    {
        return right;
    }
    if(r>0) /*产生右括号的概率大 */
    {
        formula+=")";
        return right+1;
    }
    return 0;
}
string Way_1() /*最多可支持10个数参与计算   有乘除 有括号 10以内 加减有负数 除法有余数*/
{
    string formula="";
    int length=rand()%9+2; /*随机产生表达式中操作数的个数 2-10 个*/
    int left=0,right=0,flag=0,left_1;
    for(int i=0;i<length-1;i++)
    {
        left_1=left;
        left=Bracket_l(left,formula);
        if(left_1!=left)     /*产生了左括号  flag=i*/
        {
            flag=i;
        }
        //cout<<Operands_3();
        formula+=Operands_4();
        if(left>right&&flag!=i) /*左括号大于右括号的个数 and 产生左括号和右括号不在一个循环里  即不会产生“（随机数）” 这种无效情况*/
        {
            right=Bracket_r(right,formula);
        }
        Operator_1(formula);  /*有乘除*/
    }
   // cout<<Operands_3(); /*因为 一个操作数一个运算符   还缺少一个操作数 （0 -- 9）*/
    formula+=Operands_4();
    for(int i=0;i<left-right;i++)
    {
        //cout<<")";
        formula+=")";
    }
   // cout<<" = "<<endl;
    return formula+="#";
}

string Way_2() /*最多可支持10个数参与计算   没乘除 有括号 10以内 加减有负数 除法有余数*/
{
    string formula="";
    int length=rand()%9+2; /*随机产生表达式中操作数的个数 2-10 个*/
    int left=0,right=0,flag=0,left_1;
    for(int i=0;i<length-1;i++)
    {
        left_1=left;
        left=Bracket_l(left,formula);
        if(left_1!=left)     /*产生了左括号  flag=i*/
        {
            flag=i;
        }
        //cout<<Operands_3();
        formula+=Operands_4();
        if(left>right&&flag!=i) /*左括号大于右括号的个数 and 产生左括号和右括号不在一个循环里  即不会产生“（随机数）” 这种无效情况*/
        {
            right=Bracket_r(right,formula);
        }
        Operator_2(formula);  /*有乘除*/
    }
   // cout<<Operands_3(); /*因为 一个操作数一个运算符   还缺少一个操作数 （0 -- 9）*/
    formula+=Operands_4();
    for(int i=0;i<left-right;i++)
    {
        formula+=")";
    }
    return formula+="#";
}
string Way_3() /*最多可支持10个数参与计算   没乘除 有括号 10以内 加减有负数 除法有余数*/
{
    string formula="";
    int length=rand()%9+2; /*随机产生表达式中操作数的个数 2-10 个*/
    int left=0,right=0,flag=0;
    for(int i=0;i<length-1;i++)
    {
        formula+=Operands_4();
        Operator_1(formula);  /*有乘除*/
    }
   // 因为 一个操作数一个运算符   还缺少一个操作数 （0 -- 9）*/
    formula+=Operands_4();
    return formula+="#";
}
string Way_4() /*最多可支持10个数参与计算   没乘除 没括号 10以内 加减有负数 除法有余数*/
{
    string formula="";
    int length=rand()%9+2; /*随机产生表达式中操作数的个数 2-10 个*/
    int left=0,right=0,flag=0;
    for(int i=0;i<length-1;i++)
    {
        formula+=Operands_4();
        Operator_2(formula);  /*有乘除*/
    }
   // 因为 一个操作数一个运算符   还缺少一个操作数 （0 -- 9）*/
    formula+=Operands_4();
    return formula+="#";
}
//*****************************************************************************
double jisuan(double x,double y,char oper)
{ 
    switch(oper)
    {
    case '+':
        {
            return x+y;
            break;
        } 
    case '-':
        {
            return x-y;
            break;
        }
    case '*':
        {
            return x*y;
            break;
        } 
    case '/':
        {
            return x/y;
            break;
        }  
    }
    return 0;
}

typedef struct{
    double *base;
    double *top;
    int stacksize;
}SqStack;
//初始化化栈
double InitStack(SqStack &S)
{
    S.base=new double[N];
    if(!S.base)
        exit(0);
    S.top=S.base;
    S.stacksize=N;
    return 1;
}

//入栈操作代码
char push(SqStack &S,char s)
{
    if(S.top-S.base==S.stacksize)
        return 0;
    *S.top=s;
    S.top++;
    return s;
}

double push1(SqStack &S,double s)
{
    if(S.top-S.base==S.stacksize)
        return 0;
    *S.top=s;
    S.top++;
    return s;
}
//出栈操作代码
char pop(SqStack &S)
{
    char x;
    if(S.top==S.base)
        return 0;
    --S.top;
    x=*S.top;
    return x;
}

double pop1(SqStack &S)
{
    double x;
    if(S.top==S.base)
        return 0;
    --S.top;
    x=*S.top;
    return x;
}
//取栈顶元素
double GetTop(SqStack S)
{
    if(S.top==S.base)
        exit(1);
    return *(S.top-1);
}

char precede(char ch1,char ch2)
{
    int i,j;
    char a[7][7]={        //优先级对照表，依次为+ - * / （ ） #
        //  +   -   *   /   (   )   #
        '>','>','<','<','<','>','>',    // +
        '>','>','<','<','<','>','>',    // - 
        '>','>','>','>','<','>','>',    // * 
        '>','>','>','>','<','>','>',    // /
        '<','<','<','<','<','=','0',    // (
        '>','>','>','>','0','>','>',    // ）
        '<','<','<','<','<','0','='     // #
    };
    switch(ch1)
    {
        //优先级与矩阵匹配
    case '+':
        {
            i=0;
            break;
        }
    case '-':
        {
            i=1;
            break;
        }
    case '*':
        {
            i=2;
            break;
        }
    case '/':
        {
            i=3;
            break;
        }
    case '(':
        {
            i=4;
            break;
        }
    case ')':
        {
            i=5;
            break;
        }
    case '#':
        {
            i=6;
            break;
        }
    }
    switch(ch2)
    {
        //优先级与矩阵匹配
    case '+':
        {
            j=0;
            break;
        }
    case '-':
        {
            j=1;
            break;
        }
    case '*':
        {
            j=2;
            break;
        }
    case '/':
        {
            j=3;
            break;
        }
    case '(':
        {
            j=4;
            break;
        }
    case ')':
        {
            j=5;
            break;
        }
    case '#':
        {
            j=6;
            break;
        }
    }
    return a[i][j];
}

double calculate(string str)
{
    int i=0,j=0,k=0,w=0;
    int s=str.length();
    double a[N]={0};
    char b[N]={0};
    int clu[N]={0};
    for(k=0;k<s;)
    {
        if(str[k]>='0'&&str[k]<='9')
        {
            while(str[k]>='0'&&str[k]<='9')
            {
                a[i]=(a[i])*10+(str[k]-48);
                k++;
            }
            i++;
            clu[w]=1;
            w++;
        }
        else
        {
            b[i]=str[k];
            k++;
            i++;
            clu[w]=2;
            w++;
        }
    }
    double result;
    i=0;
    SqStack optr,opnd;
    InitStack(optr);
    push(optr,'#');
    InitStack(opnd);
    push(opnd,'#');
    while(clu[i]!=0&&b[i]!='#'||GetTop(optr)!='#'&&i<s)
    {
        if(clu[i]==1)
        {
            push1(opnd,a[i]);
            //cin>>ch;
            i++;
        }
        else
            switch(precede(GetTop(optr),b[i])){
            case '<':
                {
                    push(optr,b[i]);
                    i++;
                    break;
                }
            case '>':
                {
                    double y=pop1(opnd);
                    double x=pop1(opnd);
                    char ch=pop(optr);
                    result=jisuan(x,y,ch);
                    push1(opnd,result);
                    break;
                }
            case '=':
                {
                    pop(optr);
                    i++;
                    break;
                }
        }
    }
    return result;
}
//********************************************************
int main() /*主函数*/
{
    srand((unsigned)time(0));
    int number=0,a,b;
    cout<<"------------------------------四则运算---------------------------------"<<endl;
    cout<<"是否有乘除：是1否0:";
    cin>>a;
    while(a!=0&&a!=1)
    {
        cout<<"输入有误！！！请重新输入：";
        cin>>a;
    }
    cout<<"是否有括号：是1否0:";
    cin>>b;
    while(b!=0&&b!=1)
    {
        cout<<"输入有误！！！请重新输入：";
        cin>>b;
    }
    if(a==1&&b==1)
        cout<<"最多可支持10个数参与计算  有乘除 有括号 100以内  加减有负数 除法有余数"<<endl;
    if(a==0&&b==1)
        cout<<"最多可支持10个数参与计算  无乘除 有括号 100以内  加减有负数 除法有余数"<<endl;
    if(a==1&&b==0)
        cout<<"最多可支持10个数参与计算  有乘除 无括号 100以内  加减有负数 除法有余数"<<endl;
    if(a==0&&b==0)
        cout<<"最多可支持10个数参与计算  无乘除 无括号 100以内  加减有负数 除法有余数"<<endl;
    cout<<"-----------------------------------------------------------------------"<<endl;
    cout<<"请输入题目的数量：";
    int nu;
    cin>>nu;
    for(int num=0;num<nu;num++)
    {
        string s;
        if(a==1&&b==1)
        {
            cout<<num+1<<"、";
            s=Way_1();
        }
        if(a==0&&b==1)
        {
            cout<<num+1<<"、";
            s=Way_2();
        }
        if(a==1&&b==0)
        {
            cout<<num+1<<"、";
            s=Way_3();
        }
        if(a==0&&b==0)
        {
            cout<<num+1<<"、";
            s=Way_4();
        }
        for(int i=0;i<s.length()-1;i++)
        {
            cout<<s[i];
        }
        cout<<"=";
        double a;
        cin>>a;
        if(a==calculate(s))
        {
            cout<<"---恭喜你！回答正确！"<<endl;
            number++;
        }
        else
        {
            cout<<"---很遗憾！回答错误！正确答案为："<<calculate(s)<<endl;
        }
    }
    cout<<"-----------------------------------------------------------------------"<<endl;
    cout<<"		您一共做对了"<<number<<"道题！ 所得分数为__"<<100/nu*number<<"分__"<<endl;
    cout<<endl;
    return 0;
}

运行结果：

无括号，无乘除：

有括号，有乘除：

无乘除，有括号：

实验总结： 

     编写四则运算，极大得提高了我的编程能力，和同学的结组编程能提高了我的表达和理解能力，收获很大。 

 计划：

日期任务	听课	编写程序	查阅资料	日总计
星期一	2		1	3
星期二		2		2
星期三		5		5
星期四	2		1	3
星期五		3		3
星期六		4		4
星期日
周总计	4	14	2	20

日志：

日期	开始	结束	中断	总时间	具体活动	备注
3/14	14：00	15：50	30	110	听课	软件工程
	16：00	17：00	无中断	60	查阅数据结构资料	查资料
3/15	16：10	18:10	10	110	编写程序	栈的基本操作编写
3/16	15：10	16：10	无中断	80	编程序	char类型输入，10以内运算
	18:00	19:10	无中断	70	编写程序	将产生式子与计算结果的代码结合，完成正误判断
	19:30	22:30	30	150	编写程序	修复char与int之间的转换bug
3/17	14：00	15：50	10	100	听课	软件工程
3/18	16:00	18:00	30	90	编程序
3/18	19:00	23:30	30	240	编程序	char->double转换，完成多位数的计算
3/19	7:30	9:40	10	120	代码整合，找bug
	9:40	10:40	60	1040min	调试+博客	写博客

缺陷日志记录：

日期	编号	引入阶段	排除阶段	修复时间&问题描述
3/14
3/15	1	编码	编译	栈的操作返回值类型出现问题，将其转换为char
3/16	2	编码	编译	修复char与int之间的转换bug
3/17	3	编码	编译	char->double转换，修复小数的bug
3/18	4	编码	编译	只能一位数的运算，添加了三个数组，解决这个bug
3/19	4	调试	修复	解决用户输入问题，然后判断正误

结队照片：