结对编程项目阶段性进展

第一阶段目标 - 能把计算的功能封装起来，通过测试程序和API 接口测试其简单的加法功能。

　　因为原本的设计，就设计了计算器类，将其封装好了，所以直接跳过了第一阶段。

第二阶段目标 - 通过测试程序和API 接口测试其简单的加减乘除功能。并能看到代码覆盖率。

　　

　　可以从图中看出，正负小数，正负分数等结果的计算正确性

　　而计算器类的使用也非常方便，如下代码

Calculator cal("1+1");        //初始化计算器类
cal.recalculator("1+1");    //可重复调用的计算函数
cal.run();                        //计算结果
cal.getMyResult();            //获得计算结果，为string类型

第三阶段目标 - 通过测试程序和API 接口测试对于各种参数的支持。并能看到代码覆盖率。 

　　第三阶段中加入了三个辅助计算的参数，故对此修改计算器类，此部分代码还添加了出错处理，后续部分会说明，添加代码如下：

public:
        MyError setDateRange(int type){                //设置数据范围 
        if(0<type){
            daterange=type;
            return ERROR_NO;
        }
        else
            Error=ERROR_SET;
        return ERROR_SET;
    } 
    
    MyError setMaxUnit(int num){                //设置最大识别数量 
        if(0<num&&num<=80){
            maxunit=num;
            u=new unit[maxunit];             //清空后缀表达式 
            this->num=0; 
            return ERROR_NO;
        }
        else
            Error=ERROR_SET;
        return ERROR_SET;
    }
    
    MyError setAccuracy(int a){                    //设置精度 
        if(a>=-1&&a<=6){
            accuracy=a;
            return ERROR_NO;
        }
        else
            Error=ERROR_SET;
        return ERROR_SET;
    }
private:
    //非辅助计算参数，设置后，除非重复设置，否则不会被clear之类的清除 
    int daterange;                    //算式参数中数据的范围 
    int maxunit;                    //算式参数最多能识别的字符数量 
    int accuracy;                    //小数精确位数,-1为不精确，即去掉所有末尾的0，其他数字即小数点后保留的位数 

　　daterange参数，表示计算器类只能计算-daterange到daterange之间的数据，故如果计算结果超出范围，就会报超出范围的错，默认为100000

　　maxunit参数，代表输入的算式参数最多含有几个字符，超出字符会报非法算式的错误，默认为80

　　accuracy参数，代表最后输出的计算结果的精度，-1代表原样输出，0-6代表，具体保留几位小数，采取四舍五入。

enum MyError{ERROR_NO=0,ERROR_SET=1,ERROR_OPERATOR=2,ERROR_ZERO=4,ERROR_STRING=8,ERROR_RANGE=16};

　　新定义的错误枚举类型，包含了所有计算器类会报的错误，并且将原本计算器类中的bool类型的error替换成了MyError类型的Error，里面存储的上一个错误类型，默认为ERROR_NO(没错误)

　　并且将原先所有返回-1的代码，全部替换成了返回具体错误类型

　　

　　在程序最开始调用了cal.setDateRange(1); 函数，即设置计算器类只能计算-1到1的数，结果如上图，只有第一题还能计算，余下所有题目会报错，并会显示错误类型，其他错误类型也是如此，就不过多展示了

  

第四阶段目标 -界面模块，测试模块和核心模块的松耦合。

 　　因为，界面模块的代码还没有写完，所以，第四阶段为下一周的任务，我会和同组的一起攻克这一阶段的目标的

下面是目前所有的代码

#include <iostream>
using namespace std; 
#include <string.h>
#include <stack>
#include <sstream>
#include <fstream>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

enum MyError{ERROR_NO=0,ERROR_SET=1,ERROR_OPERATOR=2,ERROR_ZERO=4,ERROR_STRING=8,ERROR_RANGE=16}; 

void printError(MyError me){
    if(me==ERROR_NO){
        cout<<"没有错误";
    }
    else if(me==ERROR_SET){
        cout<<"设置参数非法";
    }
    else if(me==ERROR_OPERATOR){
        cout<<"操作符非法";
    }
    else if(me==ERROR_ZERO){
        cout<<"除0错误";
    }
    else if(me==ERROR_STRING){
        cout<<"算式非法";
    }
    else if(me==ERROR_RANGE){
        cout<<"计算结果超出范围";
    }
    else{
        cout<<"未定义的错误类型";
    } 
    cout<<"    错误代码:"<<me<<endl<<endl;
}

class unit                        //后缀表达式用，单元类 
{
public:
    char op;
    double num;
    int kind;
    unit(){
        kind=0;
    }
    void set(char c){
        op=c;
        kind=1;
    }
    void set(double d){
        num=d;
        kind=2;
    }
};

class fenshu                        //分数类 
{
public:
    int fz;
    int fm;
    fenshu(int a,int b){
        fz=a;fm=b;
        yuefen();
    }
    void yuefen(){
        if(fz==0)
            return; 
        int t;
        int a=fz;
        int b=fm;
        if (a < b) {
            t = a;
            a = b;
            b = t;
        }
        while (t = a % b) {
            a = b;
            b = t;
        }
        if(b!=1){
            fz/=b;
            fm/=b;
        }
        if(fm<0){
            fz=-fz;
            fm=-fm;
        }
    }
    void print(){
        cout<<fz<<"/"<<fm;
    }
    string getfenshu(){
        char s[20];
        if(fm==1){
            sprintf(s,"%d",fz);
        } 
        else{
            sprintf(s,"%d/%d",fz,fm);
        } 
        string ss=s;
        return ss;
    }
    fenshu operator +(fenshu &fs){
        fenshu f(fz*fs.fm+fs.fz*fm,fm*fs.fm);
        f.yuefen();
        return f;
    }
    fenshu operator -(fenshu &fs){
        fenshu f(fz*fs.fm-fs.fz*fm,fm*fs.fm);
        f.yuefen();
        return f;
    }
    fenshu operator *(fenshu &fs){
        fenshu f(fz*fs.fz,fs.fm*fm);
        f.yuefen();
        return f;
    }
    fenshu operator /(fenshu &fs){
        if(fs.fz==0){
            fenshu f1(0,1);
            return f1;
        }
        fenshu f(fz*fs.fm,fm*fs.fz);
        f.yuefen();
        return f;
    }
    void operator =(fenshu &fs){
        fz=fs.fz;
        fm=fs.fm;
    }
    bool operator ==(fenshu &fs){
        return fz==fs.fz&&fm==fs.fm;
    }
};

class Calculator                    //核心计算器类 
{
public:
    //辅助计算参数 
    double result;                    //计算结果 
    fenshu fresult;                    //分数计算结果 
     MyError Error;                    //计算过程中是否有错误 
     string str;                        //存放中缀表达式 
     
    Calculator(string s):fresult(1,1){            //计算器初始化 
        u=new unit;
        clear();
        str=s;
        accuracy=-1; 
        maxunit=80;
        daterange=100000;
    }
    
    MyError run(){                        //计算表达式的值，存入result
        MyError temperror=zzh(str); 
        if(temperror!=ERROR_NO){
            Error=temperror;
            result=-11111;
            return Error;
        }
        int i;
        bool b=true;
        for(i=0;i<str.size();i++){    //没有小数点，就计算分数结果 
            if(str[i]=='.'){
                b=false;
                break;
            }
            
        }
        
        if(b){
            temperror=getFResult();
            if(temperror!=ERROR_NO){
                fenshu f(-1,-1);
                fresult=f;
                Error=temperror;
                return Error;
            }
            else if(abs(fresult.fz)>daterange||abs(fresult.fm)>daterange){
                Error=ERROR_RANGE;
                return Error;
            } 
        }
        else{
            temperror=getResult();
            if(temperror!=ERROR_NO){
                Error=temperror;
                result=-11111;
                return Error;
            }
            else if(abs(result)>daterange){
                Error=ERROR_RANGE;
                return Error;
            } 
        }
        return ERROR_NO;
    }
    
    void clear(){                    //清空计算器一切辅助计算参数 
        num=0;
        Error=ERROR_NO;
        result=0;
        fenshu f(1,1);
        fresult=f; 
        str="";
        delete u; 
        u=new unit[maxunit]; 
    }
    
    void recalculator(string s){    //重启计算器对象 
        clear();
        str=s;
    }
        
    string getMyResult(){                                //获得计算结果，小数结果或者分数结果 
        int i=0;
        char s[20];
        string ss;
        for(;i<str.size();i++){
            if(str[i]=='.'){
                if(accuracy!=-1)                            //判断精度并输出 
                    sprintf(s,"%.*lf",accuracy,result);
                else
                    sprintf(s,"%g",result);
                ss=s;
                return ss; 
            }
        }
        ss=fresult.getfenshu();
        return ss;
    } 
    
    MyError setDateRange(int type){                //设置数据范围 
        if(0<type){
            daterange=type;
            return ERROR_NO;
        }
        else
            Error=ERROR_SET;
        return ERROR_SET;
    } 
    
    MyError setMaxUnit(int num){                //设置最大识别数量 
        if(0<num&&num<=80){
            maxunit=num;
            u=new unit[maxunit];             //清空后缀表达式 
            this->num=0; 
            return ERROR_NO;
        }
        else
            Error=ERROR_SET;
        return ERROR_SET;
    }
    
    MyError setAccuracy(int a){                    //设置精度 
        if(a>=-1&&a<=6){
            accuracy=a;
            return ERROR_NO;
        }
        else
            Error=ERROR_SET;
        return ERROR_SET;
    }
    
private:
    //非辅助计算参数，设置后，除非重复设置，否则不会被clear之类的清除 
    int daterange;                    //算式参数中数据的范围 
    int maxunit;                    //算式参数最多能识别的字符数量 
    int accuracy;                    //小数精确位数,-1为不精确，即去掉所有末尾的0，其他数字即小数点后保留的位数 
    
    //辅助计算参数 
    unit *u;                        //存储后缀表达式 
     int num;                        //后缀表达式unit数量 
     
    MyError zzh(string s){                        //中缀表达式转后缀表达式
        if(s.size()>maxunit){ 
            return ERROR_STRING;                //error,传入的算式长度超过设置的最大识别数量
        } 
        char c; 
        char *temp1=new char[maxunit];
        double temp;
        string stemp;
        stack<char> st;
        while(!s.empty()){                    //如果字符串不为空则继续循环 
            c=s[0];
            if(isoperator(c)){                //是操作符 
                s.erase(0,1);                //从string中删除操作符  
                if(pushintostack(c,&st)==ERROR_OPERATOR)
                    return ERROR_OPERATOR;
            }
            else if(isnum(c)){                            //是数字 
                stringstream sst(s);
                sst>>temp;
                sprintf(temp1,"%g",temp);
                stemp=temp1;
                s.erase(0,stemp.size());    //从string中删除数字
                sst.clear(); 
                u[num++].set(temp);            //存储数字到栈中 
            }
            else{
                return ERROR_STRING;
            }
        } 
        if(pushintostack('#',&st)==ERROR_OPERATOR)
            return ERROR_OPERATOR;
        return ERROR_NO;
    }
    
    bool isoperator(char c){                //判断是否是操作符 
        if(c=='+')
            return true; 
        if(c=='-')
            return true; 
        if(c=='*')
            return true; 
        if(c=='/')
            return true; 
        if(c=='(')
            return true; 
        if(c==')')
            return true;     
        return false;
    }
    
    bool isnum(char c){
        if(c>='0'&&c<='9')
            return true;
        return false;
    }
    
    int youxian(char c1,char c2){            //判断两操作符优先级 
        if(c2=='#')        //结束符 
            return 0;
        if(c2=='(')
            return 1;
        if(c2==')')
            if(c1=='(')
                return 2;
            else
                return 0;
        if(c1=='(')
            if(c2=='+'||c2=='-'||c2=='*'||c2=='/')
                return 1;
        if(c1=='*'||c1=='/')
            return 0;
        if(c1=='+'||c1=='-')
            if(c2=='*'||c2=='/')
                return 1;
            else if(c2=='+'||c2=='-')
                return 0; 
        return -1;                            //非法运算符 
    }
    
    MyError pushintostack(char c,stack<char> *st){        //将操作符执行一系列入栈判断操作 
        char a;
        int y=0;
        while(!st->empty()){
            a=st->top();
            y=youxian(a,c);
            if(y==0){                //后来的操作符优先级小 
                st->pop();
                u[num++].set(a);
            }
            else if(y==1){            //后来的操作符优先级大 
                break;
            }
            else if(y==2){            //俩操作符是'('和')'
                st->pop();
                return ERROR_NO;
            }
            else
                return ERROR_OPERATOR;
        }
        st->push(c);
        return ERROR_NO;
    }
    
    void test(){                                    //输出后缀表达式，测试用（暂留） 
        int i;
        cout<<num<<endl;
        for(i=0;i<num;i++){
            if(u[i].kind==1)
                cout<<u[i].op<<" ";
            else if(u[i].kind==2)
                cout<<u[i].num<<" ";
        }
    }
    
    MyError getResult(){                        //由run函数调用，获取小数结果，存入result中 
        int i;
        char op;
        double num1,num2;
        stack<double> st;
        for(i=0;i<num;i++){                    //处理后缀表达式 
            if(u[i].kind==2){                //如果是数字则入栈 
                st.push(u[i].num);
            }
            else if(u[i].kind==1){            //如果是操作符，则出栈两个数字 
                op=u[i].op;
                if(st.empty()) 
                    return ERROR_STRING;    //算式非法
                num2=st.top();
                st.pop();
                if(st.empty())                 
                    return ERROR_STRING;    //算式非法
                num1=st.top();
                st.pop();
                switch(op){
                case '+':
                    st.push(num1+num2);
                    break;
                case '-':
                    st.push(num1-num2);
                    break;
                case '*':
                    st.push(num1*num2);
                    break;
                case '/':
                    if(num2==0)             
                        return ERROR_ZERO;    //除0错误
                    st.push(num1/num2);
                    break;
                } 
            }
            else                 
                return ERROR_STRING;        //算式非法
        }
        result=st.top();
        return ERROR_NO;
    } 
    
    MyError getFResult(){                        //由run函数调用，获取分数结果，存入fresult中 
        int i;
        char op;
        fenshu f1(1,1),f2(1,1);
        stack<fenshu> st; 
        for(i=0;i<num;i++){
            if(u[i].kind==2){                //如果是数字则入栈 
                st.push(fenshu(u[i].num,1));
            }
            else if(u[i].kind==1){            //如果是操作符，则出栈两个数字 
                op=u[i].op;
                if(st.empty())                 
                    return ERROR_STRING;    //算式非法
                f2=st.top();
                st.pop();
                if(st.empty())                 
                    return ERROR_STRING;    //算式非法
                f1=st.top();
                st.pop();
                switch(op){
                case '+':
                    st.push(f1+f2);
                    break;
                case '-':
                    st.push(f1-f2);
                    break;
                case '*':
                    st.push(f1*f2);
                    break;
                case '/':
                    if(f2.fz==0)            
                        return ERROR_ZERO;    //除0错误 
                    st.push(f1/f2);
                    break;
                } 
            }
            else                 
                return ERROR_STRING;        //算式非法
        }
        fresult=st.top();
        return ERROR_NO;
    } 
    
}; 

int main(int argc, char** argv) {
    ifstream in("equation.txt");                //打开算式所在文件 
    Calculator cal("1+1");                        //创建计算器类 
    string s;
    string answer;
    int i=0,j;
    bool b;
    int zq=0,cw=0; 
    MyError temperror;
    if(!in){
        cout<<"打开文件出错"<<endl;
        return -1;
    }
    while(in>>s){
        b=true;
        cal.recalculator(s);                    //重启计算器，并传入算式参数                 
        cout<<"第"<<++i<<"题:"<<endl;            //在屏幕上打印题号     
        temperror=cal.run();                    //让计算器计算结果
        if(temperror!=ERROR_NO){                //算式非法 
            printError(temperror);
            continue;
        }
        cout<<s<<"=";                            //在屏幕上打印题目 
        cin>>answer;                            //获得用户输入的结果 
        if(answer==cal.getMyResult())            //判断正误 
                b=true;
            else
                b=false; 
        if(b){                                    //判断正误后输出交互结果 
            cout<<"答案正确"<<endl; 
            zq++;
        }
        else{
            cout<<"答案错误"<<endl;
            cout<<"正确答案是："<<cal.getMyResult()<<endl;
            cw++;
        }
        cout<<endl;
    }
    cout<<"总共"<<zq+cw<<"道题，答对"<<zq<<"道，答错"<<cw<<"道";                 //最后输出此次作业的结果 
    in.close();
    return 0;
}