软工网络结对编程作业

软工网络结对编程作业

0. 团队成员

姓名 学号 博客园首页 码云主页
孙志威 20152112307 Agt Eurekaaa
孙慧君 201521123098 野原泽君 野原泽君

1. 需求分析：针对现有代码的改进分析，新开发功能的分析。

1. 题目需求：

  • 原题要求：
    • 写一个能自动生成小学四则运算题目的命令行 “软件”：
      • 除了整数以外，还要支持真分数的四则运算，真分数的运算，例如：1/6 + 1/8 = 7/24;
      • 运算符为 +, −, ×, ÷；
      • 并且要求能处理用户的输入，并判断对错，打分统计正确率
      • 要求能处理用户输入的真分数， 如 1/2, 5/12 等；
      • 使用 -n 参数控制生成题目的个数，例如执行下面命令将生成10个题目 ：Myapp.exe -n 10。
    • 把这个程序做成GUI:
      • 记录用户的对错总数，程序退出再启动的时候，能把以前的对错数量保存并在此基础上增量计算；
      • 有计时功能，能显示用户开始答题后的消耗时间；
      • 界面支持中文简体/中文繁体/英语，用户可以选择一种。
    • 两个任务：
      • 把计算模块提取出来，单独创建一个类。
      • 针对提取出来的计算类的接口函数做单元测试。
  • 功能改进与扩展：
    • 增加括号操作符；
    • 减少重复题目；
    • 增加一个运算符（乘方)：用符号 ^ 表示乘方，例如：4 ^ 2=16；
    • 回归测试:在开发新功能时避免损坏旧的功能，以确保新的功能不与原有功能冲突,在确认修改的功能正确之后再嵌入代码；
    • 效能分析。

2. 代码分析

  • 获取代码
    • 引用老师提供的代码为: 码云地址
    • Clone该项目
  • 分析结构

    • 类之间关系
      比较码云的链接中给出的代码只有两个类：
      TrivialCalculator 和 TrivialCalculatorTest

    • 类图

    • 逻辑分析：该项目一共只有4个函数，分别为

      • gcd 求出最大公约数
      • cal 实现两个数字的加减乘除计算
      • zfcal 实现两个分数的加减乘除
      • calinput 处理输入的字符串
        基本上都是逻辑清晰的分支结构，所以没有“逻辑泥球”

    • 测试用例

      测试用例完整覆盖了所有函数的各个分支

    • 分析现有代码需要改进的地方：

      1. 没有实现真分数和整数的同时存在：使用随机实现真分数和整数的可能同时出现。
      2. 没有实现表达式中数字个数的随机：利用宏定义统一设置表达式数字个数的最多个数，从2到设置的最多位数随机取一个数，决定表达式的数字长度。
        【表达式的生成利用循环“随机符号+随机数字”，最终去除第一位符号来得到】
      3. 码云里的代码不能运行；
      4. GUI界面有待改善；
      5. 代码可读性不强，缺少相应的注释。
      • 新开功能的分析：
      1. 添加括号：
        • 表达式中数字个数大于2时，可随机添加括号；
        • 左括号的添加位置可以为表达式前，或各个运算符的后面（除了最后一个运算符），右括号的添加位置可以为表达式的最后，或与左括号相隔一个符号开始到表达式最后的每个运算符的左边。
      2. 减少重复题目：
        • 将表达式分解为多个“符号+数字”组合的数组，第一位数字前符号为“+”；
        • 对组合数组进行排序，并放入二叉树，左子节点为该父节点组合在数组中的下一位，右子节点为在数组中拥有相同上几位组合的同位的不同组合；
        • 每生成一个表达式就在该二叉树内检索插入，已存在则剔除重新生成。（直说好难理解，下面会用图解释）
      3. 添加乘方：
        • 为了减小使用者和计算机内部的计算量，将最多只添加一个二次幂或三次幂；
        • 遍历表达式字符串，得到运算符的位置，并在这些位置和表达式的末尾中随机抽取一个位置,在其右边添加"^2"或 "^3"。

2. 程序设计：针对新开发功能做设计，建议使用思维导图。

  1. 程序总体设计

  2. 所使用的二叉树算法介绍

  1. 程序主要部分介绍（C++,C++/QT,Python,C#）

    • 生成表达式(C++)：采用随机产生字符拼接成字符串的方式生成
    • 加工表达式(C++)
      • 对生成的表达式进行合法性检查
      • 在合理位置添加括号、 幂运算等操作
      • 将表达式分割为以“符号+数字”的更小元素
      • 将表达式以“元素”为单元进行统一排序
    • 避免表达式广义重复(C++)
      • 构建了一个二叉树结构用来解析排序后的表达式是否重复
      • 二叉树将添加并维护存在过的所有表达式
    • 解析表达式(python)
      • 使用C++调用python接口
      • 使用python的eval函数动态解析表达式
        所以就不用正常的中缀-后缀 + 栈解析的做法了（py大法好）
    • 前端显示(C++/QT)
      • 用QT简单的做了个显示表达式、能检测输入框答案是否正确的GroupBox
      • 然后运行时在MainWindows里new几个Box就酱
    • 单元测试部分(C#)
      • 单元测试用的是MS测试框架
      • 测试项目不需要与正常代码放在同一项目下，‘引用’功能和测试资源管理器都十分好用

  2. 各新增功能演示

    • 支持括号

    • 表达式不重复
      表达式重复的几率为0,具体算法见二叉树算法处

    • 乘方运算

  3. 测试分析结果

    • 回归测试:
      测试方法大纲

      部分测试用例

    • 代码覆盖率测试

    • 效能分析

    • 消耗最大模块

      • 发现占用绝大部分时间的都不是用户的函数
        基本都是系统调用
      • 但是在用户代码中有一个 Evaluator::initPython方法被调用了124次，实际上这里是可以优化的
      • 优化建议：将Evaluator的一些需要全局经常调用的方法设置为static的类方法，一旦init后就不需要再调用了，可以大大减少该函数的调用次数

3. 代码展示：展示每个功能的核心代码。

  • 字符串生成类

    class ExpGenerator
{
public:
    ExpGenerator();
    ~ExpGenerator();
    int getGcd(int x, int y);
    string generateRawExp();
    vector<int> findOperator(string exp);
    string addBracket(string exp);
    string addPower(string exp);
    vector<string> apartExp(string exp);
    vector<string> sortExp(vector<string> items);
    vector<string> generate(int amount,  
                 vector<double>&results);
};
    • 生成字符串
      string ExpGenerator::generateRawExp()
{
    //产生初始表达式
    string exp = "";
    char ch[5] = { '+','-','*','~','^' };
    int maxNum;

    if (NUMBER < 2)
    {
        //表达式位数小于2则报错
        exp = "ERROR!";
        return exp;
    }
    else if (NUMBER == 2)
        maxNum = 2;
    else
        maxNum = rand() % NUMBER + 2;

    for (int i = 0; i < maxNum; i++)
    {
        //以（符号+数字）*maxNum形成第一位为符号的“伪表达式”

        //随机生成符号
        char c = ch[rand() % 4];
        exp.push_back(c);

        //随机生成数字
        stringstream ss;
        string s;
        int flag = rand() % 10;
        if (flag != 0)
            //生成整数（90%）
            ss << rand() % MAX + 1;
        else
        {
            //生成分数（10%）
            int mumNum = rand() % MAX + 2;
            int sonNum = rand() % (mumNum - 1) + 1;
            sonNum /= getGcd(mumNum, sonNum);
            mumNum /= getGcd(mumNum, sonNum);
            ss << sonNum << "/" << mumNum;
        }
        ss >> s;
        exp += s;
    }

    //截去第一位符号，生成初始表达式
    exp = exp.substr(1, exp.length());
    ////cout << exp << endl;
    return exp;
}
    • 拆分字符串并排序
      vector<string>ExpGenerator::apartExp(string exp)
{
    //遍历初始表达式，以“符号+数字”的结构分割返回
    vector<string> items;
    int begin = 0;
    int end;
    unsigned int i;
    string str;
    exp = "+" + exp;
    char c;
    for (i = 0; i < exp.length(); i++)
    {
        c = exp.at(i);
        if ((c == '+' || c == '-' || c == '*' || c == '~') 
        && (i != 0))
        {
            end = i;
            str = exp.substr(begin, end - begin);
            items.push_back(str);
            begin = i;
        }
    }
    str = exp.substr(begin, exp.length() - begin);
    items.push_back(str);

    return items;
}

vector<string> ExpGenerator::sortExp(vector<string> items)
{
    //将分割后的表达式项进行排序，用于二叉树的形成
    sort(items.begin(), items.end());
    return items;
}

  • 二叉树相关

    class UniqueBinaryTree
{
public:
    UniqueBinaryTree();
    ~UniqueBinaryTree();

    // check if the tree contains the expression
    // if contains return true
    // else return false 
    // and add the unique new nodes to the tree
    bool add(vector<string>expressionVec, double answer);
    // clear the tree  but not destoryed it 
    void clear();
    // get amount of the nodes
    int nodeAmount();
    // get amount of all the resultsNodes
    int resultsAmount();
    // amount of both result node and the mormal node
    int amount();
    // Debug: show contents to the console
    void showLayer(); 
private:
    // add the result node to the last node (levelNode)
    // return true if new result added 
    // which represent that the new expression  
    //   has the same expression(without brackets) but 
    //   different answers
    bool mountAnswerToNode(PNode levelNode, double answer);
    int countAnswerNode(PNode levelNode);
    void clearAnswerNode(PNode levelNode);

    Node * head = NULL;
};
    • add函数
      bool UniqueBinaryTree::add(vector<string> expressionVec , double answer)
{
    // treat empty string as true/contains and ignore it 
    if (expressionVec.empty())
        return true;

    int length = expressionVec.size();
    PNode curNode = this->head->right; // compare each node from the first
    PNode fatherNode = this->head; 
    string currentStr;
    
    int index = 0; // the current index of stringVector
    bool isContained = false;
    while (curNode != NULL)
    {
                
        currentStr = expressionVec.at(index);
        // record the father node to support the insertion later
        fatherNode = curNode; 
        if (curNode->data == currentStr)
        {		
            curNode = curNode->left;
            // jump to the next string
            index++;
            // break when the whole expression finish
            if (index >= length)
                break;
        }
        else
        {
            curNode = curNode->right;
        }
    }
    //if not then it's an new expression
    // mount it to the tree  
    // begin from the last part they're same
    // the current node is the last node matches part of the new expression
    bool first = true;
    // if it reached the end of the expression in the last loop
    // will skip it
    while (index < length)
    {
        string curStr = expressionVec.at(index);

        PNode newNode = new Node();
        if (first)
        {
            // mount the first newNode as the rightChild
            fatherNode->right = newNode;
            first = false;
        }
        else
        {
            fatherNode->left = newNode;
        }
        
        newNode->data = curStr;
        newNode->left = NULL;
        newNode->right = NULL;
        newNode->answer = NULL;
        fatherNode = newNode;
        index++;
    }
    // now the new expression has been added to the tree

    // add the answer of the expression as well
    // and check if the answer is inside the tree 
    // if it's inside it   return false as well
    PNode lastNode = fatherNode;
    bool newAnswerAdded = this->mountAnswerToNode(lastNode,answer);
    // new answer node is unique , and been added to the tree
    return !newAnswerAdded;
}

  • 具体代码见码云Agt-TrivialCalculator

4. 程序运行：程序运行及每个功能的使用截图。

  • 以下图片分别演示了
    1. 随机生成字符串
    2. 表达式的加减乘除
    3. 表达式的括号运算符以及幂运算
    4. 用户的输入和结果正确反馈
    5. 表达式的不重复
    6. 表达式的正确解析
    7. etc...

5. 结对编程记录

  • 码云记录

  • 编码规范文档

  • PSP表格

    PSP2.1 个人开发流程 预估耗费时间（分钟） 实际耗费时间（分钟）
    Planning 计划 20 30
    Estimate 明确需求和其他相关因素，估计每个阶段的时间成本 10 30
    Development 开发 413 940
    Analysis 需求分析 (包括学习新技术) 20 60
    Design Spec 生成设计文档 60 60
    Design Review 设计复审 60 30
    Coding Standard 代码规范 3 10
    Design 具体设计 30 60
    Coding 具体编码 120 400
    Code Review 代码复审 60 200
    Test 测试（自我测试，修改代码，提交修改） 60 120
    Reporting 报告 60 120
    · 测试报告 10 20
    · 计算工作量 30 30
    · 并提出过程改进计划 60 60

6. 小结感受：

  1. 结对编程真的能够带来1+1>2的效果吗？

     关于结对编程的1+1是否大于2，我还不是很确定，原因如下。
 1. 在结对编程的过程中，同一台电脑，一个人敲代码，另一个负责复审，无可厚非会浪费掉一个人敲代码的时间，但与此同时，又节省了复审时间，这两者之间孰轻孰重我还无法准确比较；
 2.  结对编程的两个人是不可能实力相当的，于是就会有一部分时间是“队友教我做作业”的状态OvO，在这里对我（没错，我弱）的编程能力的提高是有所帮助的。这个时候相比于让队友直接上手，我们更加乐意于“队友教我做作业”，但是这个时候“教学时间”会花很多时间=-=；
 3. 我在编程时，偶尔会逻辑混乱，脑子浆糊，我可以冷静下来和我的队友分析一波，理清思路再继续编写，由此完成我们的项目，我觉得在这里结对编程相比于一个人完成代码是有所优势的；
 4. 最后一点给结对编程的优点，在编程时，两人可以发挥各自的优势，促进项目的完成，就比如：数据结构的规划是我想出来的，但我实际构建数据结构会弱一点，那么我的队友就负责完成这一个部分，我负责其他部分。

  2. 通过这次结对编程，请谈谈你的感受和体会。

     至于感受：
 1. 学好英语很重要=-=。英语学不好，命名只能用拼音全拼，非常丑！
 2. 一个项目的好的设计可能不是在开始敲代码之前就完成的，可能是编写时突然的一个灵感来完善的。在之前，我还没注意到老师说可以用二叉树，数据结构完全是我们自己分析出来的。起初决定用单纯的树，当时觉得“嗯，这个结构好像不错”，后来发现多个度的树是很难用代码实现的（OK FINE）；接着联想到了树转化为二叉树，用左孩子右兄弟的方式存储，“妙哇，节省空间又很快”；但是发觉答案的存储又成了一个问题，再次改进运用了指针。
 3. 其实，很多时候项目本身不难，如果仔细分析一波，分成一个个小块去实现，编写好项目是很容易的，只是你不愿意去认真而已。
 4. 做项目的时候合理控制一下时间。一方面，屁股都坐不住，就不要妄想做好一个项目；另一方面，沉迷代码，面对显示屏太久人也会受不了的，同时也会影响工作效率。

以上就是该博客的全部内容，喜欢请关注+转发+收藏+硬币，我们下次再见。
↑皮这一下很开心hhhhh。

posted @ 2018-03-25 21:47  野原泽君  阅读(290)  评论(3)  编辑  收藏  举报