结对项目进展第二周——模块化分析

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了结对项目进展第二周——模块化分析相关的知识,希望对你有一定的参考价值。

  结对项目第一步:把实现的四则运算程序的功能划分模块,将不同模块功能分开,从而使模块可复用,并作为独立的部分进行测试。

  优化的四则运算程序需要高内聚和低耦合。而我们组写得代码使用了树的数据结构,虽然表达起来简单易懂,算法也比较容易实现,却有着一个很大的缺点:我们在递归生成运算表达式的同事计算了表达式的结果。这样虽然算法和实现的代码都很简便,却不符合模块化的思想。

  我们选择的原型程序,一共有输入、随机生成表达式框架(只有运算符但没有数据)、在框架中填入数字并计算结果、输出共四个模块。实现的时候觉得很简单,还以为自己选择了一种不错的算法。不过现在也觉得这种算法不错,起码很新颖,但是基于可复用性强的原则来看,模块的划分就太不合理了,并且不符合低耦合高内聚的要求。根据讨论,我们决定将以前程序的主模块再细分为两个模块,分别为自动生成表达式模块和根据表达式求解模块。总之,就是将以前的模块拆开,然后重组为新的模块。

  对于自动生成表达式模块,我们现有的代码还是有很强的实用性的。面临的问题就是:如何根据表达式求解。我们一致认为不应该抛弃原来的数据结构,所以新的模块功能设置为:先获得用户输入的表达式字符串,然后将字符串转换成树结构。

  接下来面临的问题是操作数的多样性,首先要将操作数字符串转换为相应的数据类型。

  实现如下:

void CharsToInt(char *tmpstr,int flag1, int flag2, int * numer, int * demon,int i)
{
    //根据flag1判断为带分数还是真分数
    int j;
    if (flag1 != 0)
    {
        //带分数中的整数部分
        char tmpstr1[10];
        int tmpint1,tmpint2,tmpint3;
        for (j = 0; j < flag1; j++)
        {
            tmpstr1[j] = tmpstr[j];
        }
        tmpstr1[j] = \0;
        tmpint1 = atoi(tmpstr1);
        //带分数中的分子部分
        for (j = flag1+1 ; j < flag2; j++)
        {
            tmpstr1[j - flag1 - 1] = tmpstr[j];
        }
        tmpstr1[j - flag1 -1] = \0;
        tmpint2 = atoi(tmpstr1);
        //带分数中的分母部分
        for (j = flag2+1; j < i; j++)
        {
            tmpstr1[j - flag2 -1] = tmpstr[j];
        }
        tmpstr1[j - flag2 -1] = \0;
        tmpint3 = atoi(tmpstr1);
        *(numer) = tmpint1 * tmpint3 + tmpint2;
        *(demon) = tmpint2;
    }
    else
    {
        char tmpstr1[10];
        for (j = 0; j < flag2; j++)
        {
            tmpstr1[j] = tmpstr[j];
        }
        tmpstr1[j] = \0;
        *(numer) = atoi(tmpstr1);
        for (j = flag2 + 1; j < i; j++)
        {
            tmpstr1[j - flag2 -1] = tmpstr[j];
        }
        tmpstr1[j] = \0;
        *(demon) = atoi(tmpstr1);
    }
}

下一步:由表达式字符串生成树

实现函数中用到了两个栈:操作数栈&运算符栈

从表达式第一位开始读取字符,如果读到的字符不是运算符,那么就是操作数(错误的情况单考虑),操作数有分数和整数。

比如操作数为11‘2/3,这是一个带分数,现在读取到的是‘1‘,根据这个子字符串得到操作数的分子numer,分母demon。在读取的过程中,用两个标志位表示符号 ’ 和符号 /的位置。然后用CharsToInt()将这个子字符串变成Value类型的操作数,即operation.numer = 35,operation.demon = 3.

  如果读取的是运算符,还要分运算符是否为括号。为左括号进栈,为右括号则脱括号。

void Experssion::GenerateTree(string expr)
{
    stack <char> operStack;//运算符栈
    stack <Experssion *> dataStack;//数据栈
    expr += \0;
    char tmpchar,c;
    int idx = 0;
    tmpchar = expr[idx++];
    Experssion * p;
    while (operStack.size() != 0 || tmpchar != \0)
    {
        //如果不是运算符,则接收操作数,这个操作数可能为假分数,真分数,和整数。
        if (tmpchar != \0 && !IsOper(tmpchar))
        {
            int flag1 = 0;//是否为假分数的标志,为0,不是;不为0,是假分数,且这个数值表示假分数中" ‘ "的位置
            int flag2 = 0;//是否为分数的标志,为0,不是;不为0,是分数,且这个数值表示分数中"/"的位置
            char tmpstr[10];//暂时保存操作数字符串
            int numer,demon;//操作数分子分母
            int i = 0;
            while (tmpchar != \0 && !IsOper(tmpchar))
            {
                tmpstr[i] = tmpchar;
                if (tmpchar == \‘)//如果字符为" ‘ "
                {
                    flag1 = i;
                }
                if (tmpchar == /)
                {
                    flag2 = i;
                }
                tmpchar = expr[idx++];
                i++;
            }
            tmpstr[i] = \0;
            //处理这个暂存的字符串,获得分子分母
            if (flag1 == 0 && flag2 == 0)//为整数
            {
                demon = 1;
                numer = atoi(tmpstr);
            }
            else//为分数
            {
                CharsToInt(tmpstr,flag1,flag2,&numer,&demon,i);
            }
            Value operation(numer,demon);
            p = new Experssion();
            p->Result = operation;
            dataStack.push(p);
        }
        else//读取的是运算符
        {
            switch(tmpchar)
            {
            case (:
                operStack.push(();
                tmpchar = expr[idx++];
                break;
            case ):
                while(true)
                {
                    c = operStack.top();
                    operStack.pop();
                    if (c == ()
                    {
                        break;
                    }
                    p = new Experssion();
                    p->oper = c;
                    if (dataStack.size())
                    {
                        p->right = dataStack.top();
                        dataStack.pop();
                    }
                    if (dataStack.size())
                    {
                        p->left = dataStack.top();
                        dataStack.pop();
                    }
                    dataStack.push(p);
                }
                tmpchar = expr[idx++];
                break;
            default:
                if (operStack.size() == 0 || tmpchar != \0 
                    && OperLevel(operStack.top()) < OperLevel(tmpchar))
                {//进栈
                    operStack.push(tmpchar);
                    tmpchar = expr[idx++];
                }
                else
                {//出栈
                    p = new Experssion();
                    p->oper = operStack.top();
                    if (dataStack.size())
                    {
                        p->right = dataStack.top();
                        dataStack.pop();
                    }
                    if (dataStack.size())
                    {
                        p->left = dataStack.top();
                        dataStack.pop();
                    }
                    dataStack.push(p);
                    operStack.pop();
                }
                break;
            }
        }
    }
    p = dataStack.top();
    dataStack.pop();
    this->oper = p->oper;
    this->left = p->left;
    this->right = p->right;
}

最后根据生成的表达式树求解,采用递归的方法:

//由生成的表达式树求解
Value Experssion::GetResult()
{
    if (left != NULL && right != NULL)
    {
        Value LResult = left->GetResult();
        Value RResult = right->GetResult();
        switch(oper)
        {
        case +:
            Result = LResult + RResult;
            break;
        case -:
            Result = LResult - RResult;
            break;
        case *:
            Result = LResult * RResult;
            break;
        case >:    //“>”代替除号
            Result = LResult / RResult;
            break;
        }
        return Result;
    }
    else
    {
        return Result;
    }
}

 

以上是关于结对项目进展第二周——模块化分析的主要内容,如果未能解决你的问题,请参考以下文章

20172319 结对编程练习_四则运算第二周阶段性总结

20175325 第二周结对编程项目 四则运算

20165330 结对编程项目-四则运算 第二周

第二周:结对项目改进

20165312 结对学习 四则运算(第二周)

20172327 结对编程项目-四则运算 第二周 阶段总结