个人项目小总结

终于完成了“简单”的个人项目，我内心稍有拨动。由于各种因素，我的个人项目启动稍晚，后来因电脑不好使借了室友的电脑，着实命途多舛。我的开发大概分为两个阶段。第一个阶段是实现读入算式，切分文字，中缀转后缀并计算结果。当然，是小数结果。以算法知识尚在，而一气呵成。第二阶段是写分数类，并实现之。本以为更易，然遇难于实现。我自以为分数类编的十分规范完备，然而想了一整天才想明白如何实现。经测试之后终于完成。

 这个是我的分数类：

//分数类
class fraction
{
private:
    int numerator;            //分子
    int denominator;        //分母
public:
    fraction()
    {
        numerator = 0;
        denominator = 1;
    }
    fraction(int n, int d)
    {
        if (d == 0)
        {
            cout << "输入有误，分母不能为0！" << endl;
        }
        else
        {
            numerator = n;
            denominator = d;
        }
    }
    int getN()
    {
        return numerator;
    }
    int getD()
    {
        return denominator;
    }
    void setN(int n)
    {
        numerator = n;
    }
    void setD(int d)
    {
        if (d == 0)
        {
            cout << "输入有误，分母不能为0！" << endl;
            return;
        }
        else
        {
            denominator = d;
        }
    }
    //约分
    void yuefen()
    {
        int bufn, bufd, buf;
        bufn = this->numerator;
        bufd = this->denominator;
        if (bufn < bufd)
        {
            buf = bufn;
            bufn = bufd;
            bufd = buf;
        }
        while (buf = bufn%bufd)
        {
            bufn = bufd;
            bufd = buf;
        }
        if (bufd != 1)
        {
            this->numerator /= bufd;
            this->denominator /= bufd;
        }
        if (this->denominator < 0)
        {
            this->numerator *= -1;
            this->denominator *= -1;
        }
    }
    //加法
    fraction operator+(fraction &f) 
    {
        fraction fra(this->numerator*f.denominator + f.numerator*this->numerator, this->denominator*f.denominator);
        fra.yuefen();
        return fra;
    }
    //减法
    fraction operator-(fraction &f)
    {
        fraction fra(this->numerator*f.denominator - f.numerator*this->numerator, this->denominator*f.denominator);
        fra.yuefen();
        return fra;
    }
    //乘法
    fraction operator*(fraction &f)
    {
        fraction fra(this->numerator*f.numerator, this->denominator*f.denominator);
        fra.yuefen();
        return fra;
    }
    //除法
    fraction operator/(fraction &f)
    {
        if (f.numerator == 0)
        {
            cout << "除数不能为0！" << endl;
            return f;
        }
        else
        {
            fraction fra(this->numerator*f.denominator, this->denominator*f.numerator);
            fra.yuefen();
            return fra;
        }
        
    }
    //显示分数
    void printfrac()
    {
        if (denominator == 1)
        {
            cout << numerator;
        }
        else
        {
            cout << numerator << "/" << denominator;
        }
    }
    //判断相等的三个类，可拿分数和分数，int，double比较
    bool operator==(fraction &f)
    {
        if (this->numerator == f.numerator&&this->denominator == f.denominator)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator==(int &i)
    {
        if (i == (this->numerator / this->denominator))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator==(double &d)
    {
        if (d == ((double)this->numerator / this->denominator))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    //赋值
    void operator=(fraction &f)
    {
        this->numerator = f.numerator;
        this->denominator = f.denominator;
    }
};

其中约分用了更好的方法，是网上查的，“辗转相除”法，《九章算术》中的招数。

堆栈类应该都差不多，所以就不贴了。

这个是中缀转后缀：

//中缀转后缀
void infix_to_suffix(const char pre[], char post[], int &n)
{
    int i = 0, j = 0;
    Stack<char> stack;
    stack.init();

    stack.push('=');                                                // 首先把“=”放入栈底，结束标志

    while (pre[i] != '=')
    {
        if ((pre[i] >= '0' && pre[i] <= '9') || pre[i] == '.')        // 遇到数字和小数点直接写入后缀表达式
        {
            post[j++] = pre[i];
            n++;
        }
        else if (pre[i] == '(')                                        // 遇到“（”不用比较直接入栈
            stack.push(pre[i]);
        else if (pre[i] == ')')                                        // 遇到右括号将其对应左括号后的操作符（操作符栈中的）全部写入后缀表达式
        {
            while (stack.gettop() != '(')
            {
                post[j++] = stack.pop();
                n++;
            }
            stack.pop();                                            // 将“（”出栈，后缀表达式中不含小括号
        }
        else if (isoperator(pre[i]))
        {
            post[j++] = ' ';                                        // 用空格分开操作数
            n++;
            while (priority(pre[i]) <= priority(stack.gettop()))
            {
                // 当前的操作符小于等于栈顶操作符的优先级时，将栈顶操作符写入到后缀表达式，重复此过程
                post[j++] = stack.pop();
                n++;
            }

            stack.push(pre[i]);                                        // 当前操作符优先级大于栈顶操作符的优先级，将该操作符入栈
        }

        i++;
    }
    while (stack.top)                                                // 将所有的操作符加入后缀表达式
    {
        post[j++] = stack.pop();
        n++;
    }

}

这个是将double数转换成分数：

//Number to fraction
fraction Num_to_fra(double n)
{
    fraction f((int)(n * 1000), 1000);
    f.yuefen();
    return f;
}

紧接着就是将输入的玩意（字符串）转化成分数：

//将输入的数（字符形式）转化成分数fraction
fraction char_to_fraction(char str[])
{
    int j = 0;
    double x = read_number(str, &j);
    fraction f = Num_to_fra(x);
    return f;
}

其中有一些借鉴网上的代码，比如约分的方法。但除此之外的分数类及其实现完全是自己想的自己写的，这也给了我一种不错的体验。

经历了这次紧张的开发，我有点期待未来的小组开发了。