个人项目总结

class fenshu {
public:    
    int fenzi;
    int fenmu;
    
    fenshu(){
        fenzi = 1;
         fenmu = 1;
    }
    fenshu(int a, int b) {
        fenzi = a;
        fenmu = b;
    }
    fenshu(int a) {
        fenzi = a;
        fenmu = 1;
    }

    void yuefen() {
        int t;
        int a = fenzi;
        int b = fenmu;
        
        if (a < b) {
            t = a;
            a = b;
            b = t;
        }
        while (t = a % b) {
            a = b;
            b = t;
        }
        if (b != 1) {
            fenzi /= b;
            fenmu /= b;
        }
    }
    void prtfenshu(){
        yuefen();
        if (fenmu != 1)
            cout << fenzi << "\" << fenmu;
        else
           cout << fenzi;
    }
    
    fenshu operator +(fenshu &f) {
        fenshu jieguo;
        if (fenmu == f.fenmu) {
            jieguo.fenzi = fenzi + f.fenzi;
            jieguo.fenmu = fenmu;
        }
        if (fenmu != f.fenmu) {
            jieguo.fenmu = fenmu*f.fenmu;
            jieguo.fenzi = fenzi*f.fenmu + f.fenzi*fenmu;
            jieguo.yuefen();
        }
        return jieguo;
    }
    fenshu operator +(int a) {
        fenshu jieguo;
        jieguo.fenzi = a*fenmu + fenzi;
        jieguo.fenmu = fenmu;
        jieguo.yuefen();
    }
    fenshu operator -(fenshu &f){
        fenshu jieguo;
        if (fenmu == f.fenmu) {
            jieguo.fenzi = fenzi - f.fenzi;
            jieguo.fenmu = fenmu;
        }
        if (fenmu != f.fenmu) {
            jieguo.fenmu = fenmu*f.fenmu;
            jieguo.fenzi = fenzi*f.fenmu - f.fenzi*fenmu;
            jieguo.yuefen();
        }
        return jieguo;
    }
    fenshu operator *(fenshu &f) {
        fenshu jieguo;
        jieguo.fenmu = fenmu*f.fenmu;
        jieguo.fenzi = fenzi*f.fenzi;
        jieguo.yuefen();
        return jieguo;
    }
    fenshu operator /(fenshu &f) {
        fenshu jieguo;
        jieguo.fenmu = fenmu*f.fenzi;
        jieguo.fenzi = fenzi*f.fenmu;
        jieguo.yuefen();
        return jieguo;
    }
    bool operator ==(fenshu &f) {
        //yuefen();
        //f.yuefen();
            if ( fenmu == f.fenmu&&fenzi == f.fenzi) 
                return true;
            else 
                return false;
            
    }
};

分数类，实现了运算符的重构，能实现分数之间的加减法。

class input{
public:
    string zhongzhui;
    string houzhui;
    input() {
        zhongzhui = ' ';
        houzhui = ' ';
    }
    
    bool isoperator(char op);                          // 判断是否为运算符
    int priority(char op);                                // 求运算符优先级
    void postfix();    // 把中缀表达式转换为后缀表达式
                      // 由后缀表达式字符串计算相应的中值表达式的值 
    bool iffenshu();
};

input类负责从txt读取中缀表达式并转换成后缀表达式。

判断式子中有无分数

class calculator1 {
public:
    double jieguo;
    calculator1() {
        jieguo = 0;
    }
    double read_number(string str, int *i);              // 将数字字符串转变成相应的数字
    void postfix_value(string houzhui);
};

calculator类有两个分别负责将字符转化为值，或运算符，计算有分数的式子，和无分数的式子。

class pan_and_out {
public:
    string shizi;
    int numdadui;
    float huidax;
    fenshu huidaf;
    pan_and_out() :huidaf(65536){
        shizi = ' ';
        numdadui = 0;
        huidax = 65536;
    }
    void outx(){
        cout << "答对个数" << numdadui<<"    ";
        cout << shizi ;
        cin >> huidax;
    }
    void outf() {
        cout<< "答对个数" << numdadui<<"     ";
        cout << shizi;
        cin >> huidaf.fenzi;
        scanf_s("\");
         cin>> huidaf.fenmu;
    }
    void panx(float daan) {
        if (daan == huidax)
            numdadui++;
    }
    void panf(fenshu daan) {
        if (daan == huidaf)
            numdadui++;
    }
    
};

pan_and_out类负责判断输出式子，接受答案并判断。

经过这次的项目我更加深了对模块化编程的理解，再次巩固了编程语言。体会了一个个人项目制作的过程。