计算与软件工程第二次作业

作业要求https://edu.cnblogs.com/campus/jssf/infor_computation17-31/homework/10402
作业正文

作业1

一 预习第二部分个人开发技术

在团队的大流程中, 是每一个具体的个人在做开发，测试，用户界面设计，管理，交流等工作。因此, 个人在软件团队中也有个人的流程。软件系统的绝大部分模块都是由个人开发或维护的。每个人的工作质量直接影响最终软件的质量。

个人开发流程：

1.理解问题或任务
2.提出多种解决办法并估计工作量
3.其中包括寻找以前的解决方案，因为很多工作是重复性的（例如实现某些类似的web页面）
4.与相关角色交流解决问题的提案, 决定最终方案
5.执行, 把想法变成实际中能工作的代码
6.修复缺陷, 对结果负责
另外，我还了解到一个工程师的成长主要在知识方面：对具体技术的掌握、动手能力的提升，以及对问题领域的知识和经验的积累。通用的软件工程思想的提高，一定要有自己原创的思想，自己不断总结进步。

衡量个人软件过程的因素

1.项目任务大小
2.花费时长
3.质量
其中，re-work可以表示质量，由于其表明在软件开发过程中花费的时间，re-work的多少并不和最终的质量成正比关系。软件开发过程很大程度上是一个探索和实验的过程, 不同的re-work能帮助工程师深入了解项目的各个难点, 尽早交付原型, 找到最优解决方案。因此re-work是有价值的。当然, 如果一个程序员为了一个简单的问题而不断地re-work, 其工作效率就不是太高，这可以用时间花费来考虑。在团队工作中, 稳定，一致的交付时间是衡量一个员工能力的重要方面。
4.是否按时

PSP 各个阶段：计划——>开发——>报告——>时长

其中，开发包括八个子任务
需求分析 (包括学习新技术、新工具的时间)
生成设计文档 （整体框架的设计，各模块的接口，用时序图，快速原型等方法）
设计复审 (和同事审核设计文档，或者自己复审)
代码规范
具体设计（用伪代码，流程图等方法来设计具体模块）
具体编码
代码复审
测试（自我测试，修改代码，提交修改）

个人软件过程的特点:

1.不局限于某一种软件技术 (如编程语言), 而是着眼于软件开发的流程, 这样不同应用的工程师可以互相比较。
2.不依赖于考试, 而主要靠工程师自己收集数据, 然后统计提高。
3.在小型，初创的团队中, 高质量的项目需求很难找到，这意味着给程序员的输入质量不高，在这种情况下, 程序员的输出 (程序/软件) 往往质量不高, 然而这并不能全部由程序员负责。
4.PSP依赖于数据
如：需要工程师输入数据, 记录工程师的各项活动；如果数据不准确或有遗失；如果一些数据不利于工程师本人 (例如:花很多时间修改缺陷)
5.PSP的目的是记录工程师如何实现需求的效率, 而不是记录顾客对产品的满意度。

效能分析

两种分析方法：
（1）抽样（Sampling）
抽样就是当程序运行时，Visual Studio时不时看一看这个程序运行在哪一个函数内，并记录下来，程序结束后，Visual Studio就会得出一个关于程序运行时间分布的大致的印象。这种方法的优点是不需要改动程序，运行较快，可以很快地找到瓶颈。但是不能得出精确的数据，代码中的调用关系（CallTree）也不能准确表示。
（2）代码注入（Instrumentation）
代码注入就是将检测的代码加入到每一个函数中，这样程序的一举一动都被记录在案，程序的各个效能数据都可以被精准地测量。这一方法的缺点是程序的运行时间会大大加长，还会产生很大的数据文件，数据分析的时间也相应增加。同时，注入的代码也影响了程序真实的运行情况（这有点像量子物理学中的“测试的光线干扰了测试物体本身”的现象）。
作者介绍一般先用抽样的方法找到效能瓶颈所在，然后对特定的模块用代码注入的方法进行详细分析。另外，我们可以按照“效能测试，分析，改进，再效能测试”的流程，逐渐提高程序的效能和我们的编程水平。一定要避免未做效能测试就进行效能提升。

创建单元测试函数的主要步骤：

（1）设置数据（一个假想的正确的E-mail地址）；
（2）使用被测试类型的功能（用E-mail地址来创建一个User类的实体）；
（3）比较实际结果和预期的结果（Assert.IsTrue(target!= null);）。

二 程序代码

代码实现满足以下要求：
（1）能够分别能够实现小学一、二、三、四、五年级的四则运算要求， 逐步实现各个年级的难度
（2）要求能够通过输入来选择不同年级，每个年级还得区分难，中，易三个等级
（3）对于三、四、五年级需要支持括号与多个运算符（代码中的模式b符合要求）
（4）程序支持判断对错及累计得分
（5）一次可以出100道题目，而且不能重复
不足：时间功能未能设置。

代码内容

#include<iostream>
#include<cstdlib>
#include<ctime>
#include<stack>
#include<fstream>
#define length 10000//存放答案数组长度
using namespace std;
typedef long long ll;
ofstream fout("equation.txt");
char Op[] = {'+', '-', '*', '/'};
int rights;//对题数目
int wrong;//错题数目

struct num{
    ll numerator, denominator;
    num(){numerator = 0; denominator = 1;}
    num(int n) {numerator = n; denominator = 1;}
    num(int n,int d) {numerator = n; denominator = d;}
    
void operator = (num x)
    {
        numerator = x.numerator;
        denominator = x.denominator;
    }
};
#define maxl 1005
char nifix[maxl], post[maxl];
char ans[maxl];
int cnt_right, cnt_wrong;
bool error;
num res, rst;

//****分数类***//
    class fraction
    {
     private:
        int above;         //分子
        int below;         //分母
        void reduction();            //约分
        fraction makeCommond(fraction); //通分
 
    public:
        fraction()
        {             //构造函数
        }
       fraction add(fraction);      //两分数相加
       fraction sub(fraction);      //两分数相减
       fraction mul(fraction);      //两分数相乘
       fraction div(fraction);      //两分数相除
       int display(int,int);              //显示分数
       void setvalue(int ,int);                //存储分数
    };

//***********分数的约分*********//

      void fraction::reduction()
      {
        int i,comdiv,small,max;
        if(above<below)
        {
          small=above;
          max=below;
         }
        else
        {
          small=below;
          max=above;
        }
       for(i=small;i>1;i--)
       {
          if((small%i==0 )&(max%i==0) )
          break;
       }
         comdiv=i;            //最大公约数

          if(i!=0)
          {
              above/=i;
              below/=i;
           }
    }

 //*************分数的通分*************//

    fraction fraction::makeCommond(fraction frac)
    {
       int b1=below,b2=frac.below, m,s;
       if(b1>b2)
       {
        m=b1%b2;
        s=b2;
       }
        else
        {
          m=b2%b1;
          s=b1;
        }
       while(m>0)
       {
         int res=s%m;
          s=m,m=res;
       }
       int small=(b1*b2)/s;
       above=above*(small/below);
       frac.above=frac.above*(small/frac.below);
       below=small;
       frac.below=small;
       return frac;
    }
   //***************分数的相加*************//

    fraction fraction::add(fraction fr)
    {
          fraction myFraction;
          myFraction.above=above*fr.below+fr.above*below;
          myFraction.below=below*fr.below;
          myFraction.reduction();
          return myFraction;
    }
//*********************分数的相减***************//

     fraction fraction::sub(fraction fr)
     {
           fraction myFraction;
           myFraction.above=above*fr.below-fr.above*below;
           myFraction.below=below*fr.below;
           myFraction.reduction();
           return myFraction;
    }

  //*******************分数的相乘****************//

    fraction fraction::mul(fraction fr)
    { 
          fraction myFraction;
          myFraction.above=above*fr.above;
          myFraction.below=below*fr.below;
          myFraction.reduction();
          return myFraction;
    } 
//******************分数的相除***********//

    fraction fraction::div(fraction fr)
    {
        fraction myFraction; 
        myFraction.above=above*fr.below;
        myFraction.below=below*fr.above;
        myFraction.reduction();
        return myFraction;
    }

 //*********************分数答案的输入判断*************//

    int fraction::display(int a,int b)
    {
    
        if((a==above)&&(b==below))
        {
            cout<<"正确"<<endl;
            rights=rights+1;
        }
        else
        {
            cout<<"错误"<<endl;
            wrong=wrong+1;
        }
        return rights,wrong;
    } 

  //*******************分数的赋值****************//

     void fraction::setvalue(int sj1,int sj3)           
     { 
        above=sj1;
        below=sj3;
    }
//*************无分数，无余数答案判断****************//
    
     int answer(int a[],int i)
    {
        int ans;
        
        cout<<"请输入答案:"<<endl;
        cin>>ans;
          if(ans==a[i]) 
          {
              cout<<"正确"<<endl;
              rights=rights+1;
            }
          else
          {
              cout<<"错误"<<endl;
              wrong=wrong+1;
          }
          return rights,wrong;
     
    }
 //*************无分数，有余数答案判断****************//
    int answer_1(int a[],int i,int b[])
    {
        int ans,yushu;
        
        cout<<"请输入商:"<<endl;
        cin>>ans;
        cout<<"输入余数"<<endl;
        cin>>yushu;
          if((ans==a[i])&&(yushu=b[i])) 
          {
              cout<<"正确"<<endl;
               rights=rights+1;
            }
          else
          {
              cout<<"错误"<<endl;
              wrong=wrong+1;
          }
          return rights,wrong;
     
    }
 //*************产生带括号式子****************//
    void create(int maxn)
    {
        
        if(!fout)                        //如果打开失败，outfile返回值
        {
          cerr << "open error!" << endl;
         exit(1);
        }

    //首先随机生成算式中操作数的个数，其数量必须大于1 
    int lengt;//式子长度
    do{
        lengt = rand()%8;
    }while(lengt < 2);
    bool div = false;                        //用来防止出现除0错误 
    int brack_cnt = 0;                        //记录未匹配的左括号个数 
    ll num, op;
    for (int i = 1; i < lengt; i++)        //循环生成算式 
    {
        if (div)                            //若此时需要生成的数字前的负号是'/'，则需要特判此次生成的数字不能为0 
        {
            div = false;
            do{
                num = rand()%maxn;
            }while(num == 0);
            cout<< num;
            fout<< num;
            
        }
        else
        {
            num= rand()%maxn;
            fout <<num;
            cout<<num;
        }//否则直接生成数字输出 
        int tmpcnt = brack_cnt;
        for (int j = 0; j < tmpcnt; j++)    //若当前有未匹配的左括号，则对每一个未匹配的左括号，都有一定概率生成相应右括号。    
        {
            if ((rand()%5) > 2)                //生成右括号概率为0.6
            {
                brack_cnt--;
                
                fout << ")";
                cout<<")";
            }
        }
        
        op = rand()%4;                        //生成运算符 
        fout << Op[op];
        cout << Op[op];
        if (op == 3)                        //若生成了除号，则需要置相应标志位 
            div = true;
        
        if (!(rand()%3))                    //以一定概率生成左括号，概率为1/3 
        {
            fout << "(";
            cout<<"(";
            brack_cnt++;
            num= rand()%maxn;//生成左括号后必须生成一个数字和运算符，不然可能出现(15)这样的错误 
            fout <<num;
            cout<<num;
            op = rand()%4;
            fout << Op[op];
            cout<<Op[op];
            if (op == 3)
                div = true;
        }
    }
    if (div)                                //生成最后一个数字，该数字后不需要跟运算符 
    {
        div = false;
        do{
            num = rand()%maxn;
        }while(num == 0);
        fout << num;
        cout<< num;    
    }
    else
    {
        num=rand()%maxn;
        fout << num;
        cout<<num;
        
    }
    while(brack_cnt--)              //补全右括号 
    {
        fout << ")";
        cout << ")";
    }
        cout<<"=";
        fout<< endl;
        cout<<endl;
        
}
    bool isNum(char x)            //判断是否是数字
{
    return (x >= '0' && x <= '9');
}

bool isOp(char x)             //判断是否是操作符
{
    return (x == '+' || x == '-' || x == '*' || x == '/' || x == '(' || x == ')');
}

int priority(char x)          //返回一个操作符的优先级
{
    if (x == '-' || x == '+')
        return 1;
    else if (x == '*' || x == '/')
        return 2;
    else if (x == '(')
        return 0;
    else
        return -1;
}
bool nifix_to_post()
{
    memset(post, 0, sizeof(post));
    stack<char> s;                                //操作符栈，用来压操作符 
    bool havenum = false;                        
    int tmp = 0, pos = 0;                        //tmp为暂存多位数的变量，pos为后缀数组存储位置 
    for (int i = 0; nifix[i] != ''; i++)        //循环遍历中缀数组 
    {
        if (isNum(nifix[i]))                     //若当前字符是数字，则进行暂存操作。并标识已有操作数 
        {
            havenum = true;
            tmp = tmp*10 + (nifix[i]-'0');
        }
        else if (isOp(nifix[i]))                //若当前字符是操作符则进行如下操作 
        {
            //中缀表达式合法性判断，判断是否有连续两个字符相连，若有则代表出错 
            if (isOp(nifix[i-1]) && nifix[i-1] != ')' && nifix[i] != '(') 
                return true; 
            //如果操作符前有操作数，则将得到的操作数输出至后缀表达式 
            if (havenum)
            {
                havenum = false;
                post[pos++] = tmp + '0';
                tmp = 0;
            }
            //如果操作符为右括号，则按规则进行出栈如后缀表达式等操作 
            if (nifix[i] == ')')
            {
                if (s.empty())                    //中缀表达式合法性判断，判断括号匹配 
                    return true;
                while(s.top() != '(')
                {
                    post[pos++] = s.top();
                    s.pop();
                    if (s.empty())                //中缀表达式合法性判断，判断括号匹配 
                        return true;
                }
                s.pop();
            }
            else if (nifix[i] == '(')            //如果是左括号则直接入栈 
                s.push(nifix[i]);
            else                                //如果是+-*/则按规则操作 
            {
                while (!s.empty() && priority(nifix[i]) <= priority(s.top()))
                {
                    post[pos++] = s.top();
                    s.pop();
                }
                s.push(nifix[i]);
            }
        }
        else                                    //中缀表达式合法性判断，判断是否含非法符号 
            return true;
    }
    //若有操作数，则将其输出至后缀表达式 
    if (havenum)
    {
        havenum = false;
        post[pos++] = tmp + '0';
        tmp = 0;
    }
    //将栈中操作符一次输出到后缀表达式中 
    while(!s.empty())
    {
        if (s.top() == '(')                        //中缀表达式合法性判断，判断括号匹配 
            return true;
        post[pos++] = s.top();
        s.pop(); 
    }
    return false;
}
ll gcd(ll m, ll n)
{
    ll    tmp;
    tmp = m % n;
    while(tmp)
    {
        m = n;
        n = tmp;
        tmp = m % n;
    }
    return n;
}
bool cal_result()
{
    stack<num> s;                                //用来存放操作数的栈 
    for (int i = 0; i < (strlen(post)); i++)        //循环遍历后缀表达式 
    {
        if (!isOp(post[i]))                        //如果是数字则直接入栈 
        {
            num tmp(post[i]-'0', 1);
            s.push(tmp);
        }
        else
        {
            //取出两个操作数，如果操作数数量不够，则出错，返回 
            if (s.empty())
                return true;
            num b = s.top(); s.pop();
            if (s.empty())
                return true;
            num a = s.top(); s.pop();
            num c;

            if (post[i] == '+')                    //操作符是'+'，进行上述规则运算 
            {
                c.numerator = a.numerator * b.denominator + b.numerator * a.denominator;
                c.denominator = a.denominator * b.denominator;
            }
            else if (post[i] == '-')            //操作符是'-'，进行上述规则运算
            {
                c.numerator = a.numerator * b.denominator - b.numerator * a.denominator;
                c.denominator = a.denominator * b.denominator;
            }
            else if (post[i] == '*')            //操作符是'*'，进行上述规则运算 
            {
                c.numerator = a.numerator * b.numerator;
                c.denominator = a.denominator * b.denominator;
            }
            else if (post[i] == '/')            //操作符是'/'，进行上述规则运算 
            {
                if (b.numerator == 0)            //如果除的是0，则出现除法错误，返回 
                    return true;
                c.numerator = a.numerator * b.denominator;
                c.denominator = a.denominator * b.numerator;
            }
            else                                //其他情况则出错 
                return true;
            if (c.numerator != 0)                //若结果不为0，则对分子分母约分 
            {
                ll div = gcd(c.denominator, c.numerator);
                c.denominator /= div;
                c.numerator /= div;
            }
            s.push(c);                            //将约分后结果入栈 
        }
    }
    if (s.size() > 1)                            //如果所有操作符都进行相应操作数后栈内还有多个元素，则说明出错，返回 
        return true;
    res = s.top();                                //保存结果 
    s.pop();
    if (res.denominator < 0)                    //化简结果，将分母的负号移到分子上 
    {
        res.numerator = -res.numerator;
        res.denominator = -res.denominator;
    }
    return false;    
}

bool trans_ans()
{
    int i = 0;
    ll tmp = 0;
    //两个标志位分别标志用户输入的分子分母是否为负数 
    bool num_flag = false, deno_flag = false;
    //先判断分子是否为负 
    if (ans[i] == '-')
    {
        num_flag = true;
        i++;
    }
    //接收第一个数字 
    while(isNum(ans[i]))
    {
        tmp = tmp * 10 + (ans[i] - '0');
        i++;
    }
    //若第一个数为负数，则将转化过来的整数取负 
    if (num_flag)
        tmp = -tmp;
    //保存分子 
    rst.numerator = tmp;
    //分母赋初值为1 
    rst.denominator = 1;
    tmp = 0;
    //判断是否是分数 
    if (ans[i] == '/')
    {
        //判断分母是否为负数 
        if (ans[++i] == '-')
        {
            deno_flag = true;
            i++;
        }
        //接收第二个数 
        while(isNum(ans[i]))
        {
            tmp = tmp * 10 + (ans[i] - '0');
            i++;
        }
        //若第二个数为负数，则将转化过来的整数取负
        if (deno_flag)
            tmp = -tmp;
        //保存分母 
        rst.denominator = tmp;
    }
    //若分母为0，则用户输入的结果是非法的 
    if (rst.denominator == 0)
        return true;
    //若此时没有遍历所有的字符，则说明输入是非法的 
    if (i != strlen(ans))
        return true;
    //化简分母的负号，将其移至分子 
    if (rst.denominator < 0)
    {
        rst.numerator = -rst.numerator;
        rst.denominator = -rst.denominator;
    }
    //若用户输入的分子分母都是负数，则用户输入不符合规范，我们取分母为0（因为计算结果不可能出现分母为0的状况）标志这种情况的发生 
    if (num_flag && deno_flag)
        rst.denominator = 0;
    return false;
}


int main()
{
    fraction frac,frac2;
    int sj1,sj2,sf=1,sj3,sj4,r,j=1;//定义随机数及算符
    int above,below;
    int Num;//题的数量
    char nc;//运算数选择
    char sfchose;//算符选择
    char yschose;//余数选择
    char jf;//减法结果选择
    int qznum;//取值范围
    int ans_2[length];//存放正确的答案
    int ans_4[length]={0};//存放正确的余数
    srand((unsigned)time(NULL)); //srand函数是以现在系统时间作为时间种子产生随机数
    cout<<"*****欢迎使用四则运算自动出题系统*****"<<endl;
    cout<<"请对以下内容进行初始化设置："<<endl;
    cout<<"选择年级一年级（输入'1'）或二年级（输入'2')或三年级（输入'3')或四年级（输入'4')或五年级（输入'5')"<<endl;
	cin>>nc;
	if(nc=='1'){{
		cout<<"产生一年级四则运算，选择难度低输入6，中输入7,高输入8"<<endl;
	cin>>nc;
	if(nc=='6'){
		cout<<"你选择了简单模式，请输入a，建议不要设置乘除法"<<endl;}
	if(nc=='7'){
		cout<<"你选择了中等模式，请输入a，建议设置乘除法"<<endl;}
	if(nc=='8'){
		cout<<"你选择了难模式，请输入a，建议题目量大于50，要有乘除"<<endl;}
	}}
	if(nc=='2'){{
	cout<<"进入二年级四则运算，选择难度低输入6，中输入7,高输入8"<<endl;}
	cin>>nc;
	if(nc=='6'){
		cout<<"你选择了简单模式，请输入a，建议不要设置乘除法"<<endl;}
	if(nc=='7'){
		cout<<"你选择了中等模式，请输入a，建议设置乘除法"<<endl;}
	if(nc=='8'){
		cout<<"你选择了难模式，请输入a，题目量大于50，要有乘除"<<endl;}
	}
	if(nc=='3'){{
	cout<<"进入三年级四则运算，请选择难度：低选择'6';中选择'7';高的模式选择'8'"<<endl;}
	cin>>nc;
	if(nc=='6'){
		cout<<"你选择了简单模式，请输入b，进入后，建议题目小于30"<<endl;}
	if(nc=='7'){
		cout<<"你选择了中等模式，请输入b，进入后，建议题目大于30小于50"<<endl;}
	if(nc=='8'){
		cout<<"你选择了难模式，请输入b，进入后，建议题目量大于50"<<endl;}
	}
	if(nc=='4'){{
	cout<<"进入四年级四则运算，请选择难度：低选择'6';中选择'7';高的模式选择'8'"<<endl;}
	cin>>nc;
	if(nc=='6'){
		cout<<"你选择了简单模式，请输入b，进入后建议题目小于30"<<endl;}
	if(nc=='7'){
		cout<<"你选择了中等模式，请输入b，进入后建议题目大于30小于50"<<endl;}
	if(nc=='8'){
		cout<<"你选择了难模式，请输入b，进入后题目量大于50"<<endl;}
	}
	if(nc=='5'){{
	cout<<"进入五年级四则运算，请选择难度：(1)难度低的模式选择'6';(2)中等选择'7'(3)难度高的模式选择'8'"<<endl;}
	cin>>nc;
	if(nc=='6'){
		cout<<"你选择了简单模式，建议输入b，进入后，建议题目小于30"<<endl;}
	if(nc=='7'){
		cout<<"你选择了中等模式，建议输入b，进入后，建议题目大于30小于50"<<endl;}
	if(nc=='8'){
		cout<<"你选择了难模式，建议输入b，进入后，建议题目量大于50"<<endl;}
	}
    cout<<"请输入难度模式（a.二个运算数 b.多个运算数）"<<endl;
    cin>>nc;
    if(nc=='a')
    {
        cout<<"请输入打印题数："<<endl;
    cin>>Num;
    cout<<"请选择是否有乘除法?（y/n）"<<endl;
    cin>>sfchose;
    cout<<"请输入一个值确定算式中数值取值范围："<<endl;
    cin>>qznum;
    cout<<"减法结果中出现负数吗？（y/n）";
    cin>>jf;

    if(sfchose=='y')
    {
        cout<<"请选择除法有无余数?（y/n）"<<endl;
        cin>>yschose;
    }
        cout<<"********************************"<<endl;

    for(int i=0;i<Num;i++)
    {
            sj1=rand()%qznum;
            sj2=rand()%qznum;
            sj3=rand()%qznum;
            sj4=rand()%qznum;
            if(sfchose=='n')//无乘除法
            {
                 sf=rand()%4;         
            }
            if(sfchose=='y')//有乘除法
            {
                  sf=rand()%8; 
            }
            switch(sf)
                {        
                     case 0:
                       cout<<sj1<<"+"<<sj2<<"=     "<<endl;
                       ans_2[i]=sj1+sj2;
                       answer(ans_2,i);

                     break;
                    case 1:
                       if(jf=='n')//无负数
                       {
                           if(sj1<sj2)
                           {
                              cout<<sj2<<"-"<<sj1<<"=    "<<endl;
                              ans_2[i]=sj2-sj1;
                              answer(ans_2,i);
                        
                           }
                           else
                           {
                               cout<<sj1<<"-"<<sj2<<"=    "<<endl;
                               ans_2[i]=sj1-sj2;
                               answer(ans_2,i);
                           }
                        }
                       else
                       {
                            cout<<sj1<<"-"<<sj2<<"=    "<<endl;
                            ans_2[i]=sj1-sj2;
                            answer(ans_2,i);
                        
                       } 
                       break;
                  case 2:
                       if(sj1>sj3)
                       {
                           r=sj1;
                           sj1=sj3;
                           sj3=r;
                       }
                       if(sj2>sj4)
                       {
                           r=sj2;
                           sj2=sj4;
                           sj4=r;
                       }
                     cout<<"("<<sj1<<"/"<<sj3<<")"<<"+"<<"("<<sj2<<"/"<<sj4<<")=     "<<endl;
                     frac.setvalue(sj1,sj3);
                     frac2.setvalue(sj2,sj4);
                     cout<<"输入分子和分母（用空格隔开，结果化到最简）";
                     cin>>above>>below;
                     frac.add(frac2).display(above,below); 

                    break;
                  case 3:
                        if(sj1>sj3)
                        {
                            r=sj1;
                            sj1=sj3;
                            sj3=r;
                        }
                        if(sj2>sj4)
                        {
                            r=sj2;
                            sj2=sj4;
                            sj4=r;
                        }
                        if(jf=='n')//减法结果无负数
                        {
                            if((sj1/sj3)<(sj2/sj4))
                            { 
                                cout<<"("<<sj2<<"/"<<sj4<<")"<<"-"<<"("<<sj1<<"/"<<sj3<<")=     "<<endl;
                                frac.setvalue(sj2,sj4);
                                frac2.setvalue(sj1,sj3);
                                cout<<"输入分子和分母（用空格隔开，结果化到最简）";
                                cin>>above>>below;
                                frac.sub(frac2).display(above,below); 

                            }
                            else
                            {
                                cout<<"("<<sj1<<"/"<<sj3<<")"<<"-"<<"("<<sj2<<"/"<<sj4<<")=     "<<endl;
                                frac.setvalue(sj1,sj3);
                                frac2.setvalue(sj2,sj4);
                                cout<<"输入分子和分母（用空格隔开，结果化到最简）";
                                cin>>above>>below;
                                frac.sub(frac2).display(above,below); 
                            }
                        }
                         else
                         {
                                cout<<"("<<sj1<<"/"<<sj3<<")"<<"-"<<"("<<sj2<<"/"<<sj4<<")=     "<<endl;
                                frac.setvalue(sj1,sj3);
                                frac2.setvalue(sj2,sj4);
                                cout<<"输入分子和分母（用空格隔开，结果化到最简）";
                                cin>>above>>below;
                                frac.sub(frac2).display(above,below); 
                         }
                       break;
                   case 4:
                      cout<<sj1<<"*"<<sj2<<"="<<endl;
                      ans_2[i]=sj1*sj2;
                      answer(ans_2,i);
                    break;
                   case 5:
                       if(sj2==0)//分母为零则不计入总数
                       {
                           i=i-1;
                        
                       }
                       else if(yschose=='n')//除法没有余数
                       {
                           if(sj1%sj2==0)
                           {
                               cout<<sj1<<"/"<<sj2<<"="<<endl;
                               ans_2[i]=sj1/sj2;
                               answer(ans_2,i);

                        
                           }
                           else 
                           {
                               i=i-1;
                             
                           }
                       }
                       else if(yschose=='y')//除法有余数
                       {
                             if(sj1%sj2!=0)
                           {
                               cout<<sj1<<"/"<<sj2<<"="<<endl;
                               ans_2[i]=sj1/sj2;
                               ans_4[i]=sj1-sj2*ans_2[i];
                               answer_1(ans_2,i,ans_4);
                    
                           }
                           else 
                           {
                               i=i-1;
                        
                           }

                       }
                       break;
                   case 6:
                    if(sj1>sj3)
                    {
                        r=sj1;
                        sj1=sj3;
                        sj3=r;
                    }
                    if(sj2>sj4)
                    {
                        r=sj2;
                        sj2=sj4;
                        sj4=r;
                    }
                     cout<<"("<<sj1<<"/"<<sj3<<")"<<"*"<<"("<<sj2<<"/"<<sj4<<")=     "<<endl;
                     frac.setvalue(sj1,sj3);
                     frac2.setvalue(sj2,sj4);
                     cout<<"输入分子和分母（用空格隔开，结果化到最简）";
                     cin>>above>>below;
                     frac.mul(frac2).display(above,below); 
                       break;
                   case 7:
                       if(sj1>sj3)
                       {
                           r=sj1;
                           sj1=sj3;
                           sj3=r;
                       }
                     if(sj2>sj4)
                     {
                        r=sj2;
                        sj2=sj4;
                        sj4=r;
                     }
                       cout<<"("<<sj1<<"/"<<sj3<<")"<<"/"<<"("<<sj2<<"/"<<sj4<<")=     "<<endl;
                       frac.setvalue(sj1,sj3);
                       frac2.setvalue(sj2,sj4);
                       cout<<"输入分子和分母（用空格隔开，结果化到最简）";
                       cin>>above>>below;
                       frac.div(frac2).display(above,below); 
                       break;
                   default:
                   break;
                }
    }
     cout<<"共做对  "<<rights<<"  道题"<<endl;
     cout<<"共做错  "<<wrong<<"  道题"<<endl;
    }
    else
    {
        
        cout<<"请输入出题数目：";
        cin >>Num ;
        cout<<"请输入一个值确定算式中数值取值范围："<<endl;
        cin>>qznum;
        cout<<"******************************************"<<endl;
        while(Num--)
        {
            create(qznum);
        }
        //计数器请0 
    cnt_right = cnt_wrong = 0;
    ifstream infile;
    infile.open("equation.txt", ios::in);
      if(infile.is_open() == false)
      {
         cerr << "open error!" << endl;
         exit(1);
      }
        
    while( infile >> nifix)
    {
        error = nifix_to_post();            //中缀转后缀，并接受错误信息 
        if (error)                            //若过程出错，则输出错误信息 
        { 
            cout << "读取式子出错!" << endl;
            return 0; 
        }
        
        //test_post();
        
        error = cal_result();                //后缀表达式计算，并接受错误信息 
        if (error)                            //若过程出错，则输出错误信息
        { 
            cout << "计算中出错..." << endl;
            return 0; 
        }
        
        cout << "请输入答案: ";
        cin >> ans;                            //接受用户答案 
        error = trans_ans();                //答案翻译， 并接受错误信息
        if (error)                            //若过程出错，则输出错误信息
        { 
            cout << "输入不合法答案!" << endl;
            return 0; 
        }
        //若用户输入和城西计算答案的分子分母相等或分子均为0，则说明用户输入答案正确 
        if ((rst.denominator == res.denominator && rst.numerator == res.numerator) || (rst.numerator == res.numerator && rst.numerator == 0))
        {
            cnt_right++;
            cout << "正确!" << endl;
        }
        //否则答案错误，程序输出正确答案 
        else
        {
            cnt_wrong++;
            cout << "错误. 答案是 ";
            if (res.denominator == 1)
                cout << res.numerator << "." << endl;
            else
                cout << res.numerator << "/" << res.denominator << "." << endl;
        }
    }
    cout << "统计结果..." << endl;
    //输出统计结果 
    cout << "你答了" << cnt_right+cnt_wrong << " 道题 ";
    cout << "正确数：" << cnt_right << "   错误数： " << cnt_wrong << " 。" << endl;
    infile.close();
 
    }
	system("pause");
     return 0;
}

作业二

码云链接

https://gitee.com/yu66688/firstwarehouse/blob/master/jisuan.cpp