现代软件工程HW2：结对编程-生成五则运算式-Core10组 [PB16110698+PB16120162]

作业具体要求点这里

Core组要求：

1.Calc()

这个Calc 函数接受字符串的输入（字符串里就是算术表达式，例如 “5*3.5”，“7/8 - 3/8 ”，“3 + 90 * 0.3”等等），这个模块的返回值是一个字符串。

2.Setting()

在生成四则运算题目之前，需要对一系列属性进行设置，例如生成题目的数量，操作数的数量，题目中操作数的数值的范围，运算符的种类，(+-*/，是否支持真分数运算，是否支持小数运算，是否支持乘方运算……

注：

题目中操作数的数值范围对于真分数来说是指其分母的范围，运算结果可以超出指定范围

当题目中包含小数时，答案亦以小数形式给出，结果为无限小数时保留小数点后两位

乘方运算的幂次方为小于5的自然数

3.Generate()

进行一些设置之后，就可以开始生成所需要的题目了，题目增加以下限制

生成的题目计算过程中不能产生负数

　　例如1 - 2 + 3 =，3 + (4 - 5) =，因为计算过程中产生了负数，都是无效的题目

生成的题目中不能包括不必要的括号

　　例如 1 + (2 * 3)，（1 + 2）+ 3

　　其中括号为不必要的括号，不能生产此类题目

程序一次运行生成的题目不能重复

　　即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目。例如，23 + 45 = 和45 + 23 = 是重复的题目，6 × 8 = 和8 × 6 = 也是重复的题目。3+(2+1)和1+2+3这两个题目是重复的，由于+是左结合的，1+2+3等价于(1+2)+3，也就是3+(1+2)，也就是3+(2+1)。但是1+2+3和3+2+1是不重复的两道题，因为1+2+3等价于(1+2)+3，而3+2+1等价于(3+2)+1，它们之间不能通过有限次交换变成同一个题目。

实现以上接口，编写API文档，供UI组使用（亦可自行增加功能）。

PSP表格：

一、需求分析

　　①考虑本次作业的主要功能是接受setting、生成表达式，具体的Calc运算函数其实和整体关系不大，优先设计Class和setting。经过商讨，我们决定将Class名定为QuestionCore类，其中设置供setting使用的九个变量：

1.生成问题数量（int）questionNum 初值：40

2.最多操作符数（int）maxOpNum 初值：6

3.算式中数字最小值（int）minData 初值：0

4.算式中数字最大值（int）maxData 初值：15

5.操作符字符串，包括“+-*/^”（string）ops 初值：“+-*/^”，支持乱序输入，根据输入的字符串中包含的运算符进行生成算式

6.是否开启分数运算（bool）fracFlag 初值：true

7.小数精度（int）precise 初值：2

8.题目文件路径（string）QPath 初值：Questions.txt

9.答案文件路径（string）APath 初值：Answers.txt

这九个变量足以控制实现作业中的各种要求。同时，设置vector<string>容器的变量来存储结果。相应地设置相关函数。

　　②考虑生成运算式的方式，想起学习数据结构时“栈”一章里便是将生成运算式作为例题，故重拾谭浩强，初步预定采用栈来生成运算式。后来在组里讨论交流了一下，发现树结构更适合多运算式的随机生成，于是决定以树结构存储、栈形式导出，实现随机生成运算式的功能。树的结点定义结构体，索性定成一个Class：questionNode，其中包含value值、左孩子lchild、右孩子rchild和判别是数字结点还是运算符结点的bool变量opsFlag。

　　③考虑Calc函数的具体功能，是要对一个输入的式子进行运算，返回string形式的结果。基础运算即不涉及分数的基础四则运算+乘方，通过atoi、to_string等函数不难做到，拆分到CalcNum、CalcStr两个函数中，分别对输入的数字、字符串求解。追加功能要求支持分数运算，即需要通分、设置带分数等，故加入约分模块，辗转相除法求出最大公约数后进行约分，在Calc中实现。

　　④考虑封装和对接要求，应该着手学习将CPP封装为dll的方法，并且要及时发布、写好API文档，尽早对接、互相完善。由于接口定义模糊不清，可以预计各组的接口都会有所不同，应当早做准备。

　　⑤特殊之处：结对编程。需要收集一些结对编程的技巧和经验，合理分工，共同进步。

二、具体设计

　　①设计两个类：questionNode和questionCore，Node是树节点，如上所述；Core是主要变量和函数的类，包含setting所需的控制变量和实现各种功能的函数。

　　②Core类中包含树节点Node* questions和string容器Answer，分别负责生成树、存树、操作树与存储生成式子的答案。生成的式子由getQue函数配合对树的操作得到，保存在string 的容器finalQue中。这样我们就可以通过生成一定数目的式子分别将结果和表达式放入Answer和finalQue，达成功能。树的操作有各种结点遍历、检验、转换成string等。

　　③考虑计算优先级和括号问题。括号要加但不能乱加，我们商量后采用一个比较笨的办法：对每个由其他运算符和数字组建好的式子，先随机生成一定数量的成对括号，找位置往式子里填。填完后，对于无须加括号的，将括号成对删除。此处需要注意的是中途新增需求：乘方运算的右边必须是小于五的自然数，也就是说括号落位还要避免落在乘方后边。

　　④考虑筛选合格算式问题，由算式中各阶段运算非负，设计isPositive函数来判断是否每一阶段都不为负。设计函数判断两颗运算式树是否在本次作业的意义下等同。由于在树生成和转化时逐个判断算式合格过于繁琐，我们采用过量生成、取用合格算式的策略。若合格算式不够多，则再次生成补充。

　　⑤考虑对接问题，设计setting函数参数如上所述，设计getResultFile函数，直接将两个vector中的数据分别导出到客户输入的路径下设定的文件中。

三、具体编码

　　整体文件由question.h、question.cpp、main.cpp组成。question.h中声明了类和各类函数；除了构造和析构函数外，其他函数的实现均在question.cpp中进行。main函数主要用于测试功能。代码分别如下。

question.h

头文件已添加预编译头，可编译为dll文件。

 #include "Core10.h"

 //random a~b

 int questionCore::random(int a, int b)

 {

     return (rand() % (b - a + )) + a;

 }

 //is operator

 bool questionCore::isOp(char ch)

 {

     auto it = find(ops.begin(), ops.end(), ch);

     if (it == ops.end())

         return false;

     return true;

 }

 //is num

 bool questionCore::isNum(char ch)

 {

     if (ch >= ''&&ch <= '')

         return true;

     return false;

 }

 //is decimal

 bool questionCore::isDeci(string str)

 {

     for (int i = ; i < str.size(); i++)

     {

         if (str[i] == '.')

             return true;

     }

     return false;

 }

 //op's priority, higher means prior

 int questionCore::priority(char op)

 {

     switch (op)

     {

     case '#':return -;

     case '\0':return -;

     case '(':return ;

     case ')':return ;//avoid ( ) be put out

     case '+':

     case '-':return ;

     case '*':

     case '%':

     case '|':

     case '/':return ;

     case '^':return ;

     default:return ;

     }

 }

 // return (a op b)

 double questionCore::CalcNum(double a, double b, char op)

 {

     switch (op)

     {

     case '+':return (a + b);

     case '-':return (a - b);

     case '*':return (a * b);

     case '|':return a / b;

     case '/':return a / b;

     case '%':return (int)a % (int)b;

     case '^':return pow(a, b);

     default:return a;

     }

 }

 //return answer of que

 double questionCore::CalcStr(string & que)

 {//OPTR: ops' stack; OPEN: nums' stack

     int posTmp = que.find("*-");

     if (posTmp != -)

         return ;

     que.push_back('\0');

     stack<char> OPTR; OPTR.push('#');

     stack<double> OPEN;

     char ch = 'c', chTmp;

     double num1, num2;

     int pos = ;

     while (ch != '\0' || OPTR.top() != '#')

     {

         if (ch != '\0') { ch = que[pos]; pos++; }

         if (!isOp(ch) && ch != '\0')

         {

             if (ch == ' ') continue;

             else numPush(OPEN, que, pos);

             continue;

         }

         switch (ch)

         {

         case '(':OPTR.push(ch); break;

         case ')':

             chTmp = OPTR.top();

             while (chTmp != '(')

             {

                 if (OPEN.empty())

                     throw "wrong form";

                 num1 = OPEN.top(); OPEN.pop();

                 if (OPEN.empty())

                     throw "wrong form";

                 num2 = OPEN.top(); OPEN.pop();

                 OPEN.push(CalcNum(num2, num1, chTmp));

                 OPTR.pop();

                 chTmp = OPTR.top();

             }

             OPTR.pop();

             break;

         default:

             chTmp = OPTR.top();

             while (priority(chTmp) >= priority(ch))

             {

                 OPTR.pop();

                 if (OPEN.empty())

                     throw "wrong form";

                 num1 = OPEN.top(); OPEN.pop();

                 if (OPEN.empty())

                     throw "wrong form";

                 num2 = OPEN.top(); OPEN.pop();

                 OPEN.push(CalcNum(num2, num1, chTmp));

                 chTmp = OPTR.top();

             }

             if (ch != '\0')OPTR.push(ch);

             break;

         }

     }

     return OPEN.top();

 }

 //push que's nums into stackT

 void questionCore::numPush(stack<double> & stackT, string que, int & pos)

 {

     string strT;

     char ch;

     while (!isOp(que[pos - ]) && que[pos - ] != '\0')

     {

         ch = que[pos - ];

         strT.push_back(ch);

         pos++;

     }

     pos--;

     stackT.push(atof(strT.c_str()));

 }

 //find max divisor

 int questionCore::getDivisor(string str)

 {

     string numTmp;

     int times = ;

     int divisorTmp = ;

     int strLen = str.size();

     int backNum = ;

     for (int i = ; i < strLen; i++)

     {

         if (str[i] == '|' || str[i] == '/')

         {

             if (str[i + ] == '(')

             {

                 i++;

                 while (i <= strLen)

                 {

                     if (str[i] == '(')backNum++;

                     if (str[i] == ')')backNum--;

                     if (str[i] == '|' || str[i] == '/')divisorTmp *= getDivisor(str.substr(i));

                     if (divisorTmp ==  || divisorTmp>maxRange || divisorTmp<)

                         return ;

                     numTmp.push_back(str[i]);

                     if (backNum == )break;

                     i++;

                 }

             }

             else

             {

                 while (isNum(str[i + ]) && i +  <= strLen)

                 {

                     numTmp.push_back(str[i + ]);

                     i++;

                 }

             }

             numTmp.insert(, , '(');

             times *= int(CalcStr(numTmp.append(")*").append(to_string(int(divisorTmp)))));

             if (times ==  || times>maxRange || times<)

                 return ;

             numTmp.clear();

         }

     }

     if (times ==  || times>maxRange || times<)

         return ;

     return times;

 }

 //Euclidean algorithm, zhanzhuanxiangchufa

 int questionCore::gcd(int a, int b)

 {

     if (b != )

         return gcd(b, a % b);

     else

         return a;

 }

 //judge if elems in question are positive

 bool questionCore::isPositive(questionNode* root, double &res)

 {

     double res1 = , res2 = ;

     bool flag1, flag2;

     if (root == NULL) return false;

     if (root->opsFlag == true)

     {

         flag1 = isPositive(root->lchild, res1);

         flag2 = isPositive(root->rchild, res2);

         res = CalcNum(res1, res2, char(root->value));

         if (res <  || res>maxRange)return false;

         else return flag1 && flag2;

     }

     else

     {

         res = root->value;

         return true;

     }

 }

 //generate tree from ques, if success return ture

 bool questionCore::generateTree(vector<string> & ques)

 {

     vector<string> res;

     string que, numStr;

     stack<char> OPTR;

     stack<questionNode*> OPEN;

     questionNode *node1, *node2, *tempNode;

     for (int i = ; i < ques.size(); i++)

     {

         que = ques[i];

         que.push_back('\0');

         OPTR.push('#');

         char ch = 'c', chTmp;

         int pos = ;

         while (ch != '\0' || OPTR.top() != '#')

         {

             if (ch != '\0')ch = que[pos++];

             if (!isOp(ch) && ch != '\0')

             {

                 if (ch == ' ') continue;

                 else

                 {

                     while (!isOp(que[pos - ]) && que[pos - ] != '\0')

                     {

                         numStr.push_back(que[pos - ]);

                         pos++;

                     }

                     pos--;

                     tempNode = new questionNode(atoi(numStr.c_str()), false);

                     OPEN.push(tempNode);

                     numStr.clear();

                 }

                 continue;

             }

             switch (ch)

             {

             case '(':OPTR.push(ch); break;

             case ')':

                 chTmp = OPTR.top();

                 while (chTmp != '(')

                 {

                     node1 = OPEN.top(); OPEN.pop();

                     node2 = OPEN.top(); OPEN.pop();

                     tempNode = new questionNode(int(chTmp), true, node2, node1);

                     OPEN.push(tempNode);

                     OPTR.pop();

                     chTmp = OPTR.top();

                 }

                 OPTR.pop();

                 break;

             default:

                 chTmp = OPTR.top();

                 while (priority(chTmp) >= priority(ch))

                 {

                     OPTR.pop();

                     node1 = OPEN.top(); OPEN.pop();

                     node2 = OPEN.top(); OPEN.pop();

                     tempNode = new questionNode(int(chTmp), true, node2, node1);

                     OPEN.push(tempNode);

                     chTmp = OPTR.top();

                 }

                 if (ch != '\0')OPTR.push(ch);

                 break;

             }//switch

         }//while

         questions.push_back(OPEN.top());

         OPEN.pop();

     }

     return true;

 }

 //judge if 2 trees are the same

 bool questionCore::isSame(questionNode* root1, questionNode* root2)

 {

     if (root1 == NULL && root2 == NULL)

         return true;

     else if (root1 == NULL || root2 == NULL)

         return false;

     if (root2->value != root1->value)

         return false;

     else

         return isSame(root1->rchild, root2->rchild) && isSame(root1->lchild, root2->lchild);

 }

 //judge if 2 trees are equal

 bool questionCore::isEqual(questionNode* root1, questionNode* root2)

 {

     if (root1 == NULL && root2 == NULL)

         return true;

     else if (root1 == NULL || root2 == NULL)

         return false;

     bool eFlag1, eFlag2;

     if (isSame(root1, root2))

         return true;

     else

     {

         eFlag1 = isEqual(root1->lchild, root2->lchild) && isEqual(root1->rchild, root2->rchild);

         eFlag2 = isEqual(root1->rchild, root2->lchild) && isEqual(root1->lchild, root2->rchild);

         return (eFlag1 || eFlag2) && (root1->value == root2->value);

     }

 }

 //judge if tree fit conditions

 bool questionCore::judgeTree()

 {

     int rquesNum = questions.size();

     for (int i = ; i < rquesNum; i++)

     {

         fitFlag[i] = isPositive(questions[i], result[i]);

         for (int j = ; j < i; j++)

         {

             if (result[i] == result[j])

             {

                 if (isEqual(questions[i], questions[j]))

                 {

                     fitFlag[i] = false;

                     isEqual(questions[i], questions[j]);

                     break;

                 }

             }

         }

     }

     return true;

 }

 //generate questions

 vector<string> questionCore::generateQue(int queNum)

 {

     vector<string> res;

     string strTmp;

     int num, chOp;

     string numStr;

     int leftParenPos, rightParenPos;

     int opNum, parenNum;

     bool isPow = false;

     int powFlag = ;

     for (int i = ; i < queNum; i++)

     {

         opNum = random(, maxOpNum);

         for (int j = ; j < opNum; j++)

         {

             if (isPow == false)

             {

                 num = random(minRange, range);

                 numStr = to_string(num);

             }

             else

             {

                 num = random(, );

                 numStr = to_string(num);

                 isPow = false;

             }

             chOp = ops[random(, ops.size() -  - powFlag)];

             if (char(chOp) == '^')

             {

                 isPow = true;

                 powFlag = ;

             }

             strTmp.append(numStr);

             strTmp.push_back(chOp);

         }

         num = random(minRange, range);

         numStr = to_string(num);

         strTmp.append(numStr);

         parenNum = random(, opNum);

         for (; parenNum>; parenNum--)

         {

             leftParenPos = random(, strTmp.size() - );

             rightParenPos = random(leftParenPos + , strTmp.size());

             while ((leftParenPos !=  && (!isNum(strTmp[leftParenPos]) || !isOp(strTmp[leftParenPos - ]))) || (leftParenPos !=  && strTmp[leftParenPos] == '^'))

             {

                 leftParenPos--;

             }

             strTmp.insert(leftParenPos, , '(');

             while (rightParenPos != strTmp.size() && (!isNum(strTmp[rightParenPos - ]) || !isOp(strTmp[rightParenPos])))

             {

                 rightParenPos++;

             }

             strTmp.insert(rightParenPos, , ')');

         }

         res.push_back(strTmp);

         strTmp.clear();

         powFlag = ;

     }

     return res;

 }

 //transform tree to str

 void questionCore::treeToStr(questionNode* root, string &pre)

 {

     if (root == NULL) return;

     if (root->opsFlag == false)

     {

         pre.append(to_string(root->value));

         return;

     }

     if (root->lchild->opsFlag == false)

         treeToStr(root->lchild, pre);

     else if ((priority(root->value) > priority(root->lchild->value)) || (root->value == '^'))

     {

         pre.push_back('(');

         treeToStr(root->lchild, pre);

         pre.push_back(')');

     }

     else

         treeToStr(root->lchild, pre);

     pre.push_back(char(root->value));

     if (root->rchild->opsFlag == false)

         treeToStr(root->rchild, pre);

     else if ((priority(root->value) >= priority(root->rchild->value)) || (root->value == '^'))

     {

         pre.push_back('(');

         treeToStr(root->rchild, pre);

         pre.push_back(')');

     }

     else

         treeToStr(root->rchild, pre);

     return;

 }

 //transform original questions to formal questions

 vector<string> questionCore::quesToStr(vector<questionNode*> Quess)

 {

     string strTmp;

     string strExm;

     vector<string> finishStr;

     int count = ;

     int rightNum = ;

     bool flag = true;

     int dot = ;

     bool flag2 = true;

     for (int i = ; i < Quess.size(); i++)

     {

         treeToStr(Quess[i], strTmp);

         for (int j = ; j<strTmp.size() - ; j++)

             if (strTmp[j] == '^')

                 if ((strTmp[j + ] > '') || (strTmp[j + ] == '('))

                 {

                     flag = false; break;

                 }

         if (!flag) {

             strTmp.clear();

             flag = true;

             continue;

         }

         strExm = Calc(strTmp);

         for (int j = ; j < strExm.size(); j++) {

             if (strExm[j] == '\'') dot = j;

             if (strExm[j] == '|')

                 if (j - dot >  || strExm.size() - j > )

                     flag2 = false;

         }

         if (!flag2) {

             strTmp.clear();

             strExm.clear();

             flag2 = true;

             dot = ;

             continue;

         }

         finishStr.push_back(strTmp);

         strTmp.clear();

         count++;

         if (count >= quesNum)

             break;

     }

     return finishStr;

 }

 //below:public function

 //free and reset

 bool questionCore::Clear() {

     int Num = questions.size();

     for (int i = ; i < Num; i++)

     {

         questionNode* temp = questions[i];

         deleteQues(temp);

     }

     questions.clear();

     Answer.clear();

     return true;

 }

 //get real fraction and return result

 string questionCore::Calc(string inQues)

 {

     int devisor;

     int intNum;

     string tpQues;

     long res;

     if (fracFlag == true) {

         devisor = getDivisor(inQues);

         if (fracFlag&&devisor >  && devisor < maxRange && !isDeci(inQues))//get the real fraction

         {

             tpQues.append(to_string(devisor));

             tpQues.append("*(");

             tpQues.append(inQues).push_back(')');

             res = int(CalcStr(tpQues));

             intNum = gcd(res, devisor);

             tpQues = to_string(int(res / intNum));

             if (devisor / intNum != )

             {

                 if (res > devisor)

                 {

                     tpQues.clear();

                     tpQues.append(to_string(int(res / devisor))).append("'").append(to_string(int(res / intNum - int(res / devisor)*(devisor / intNum)))).append("|").append(to_string(devisor / intNum));

                 }

                 else

                     tpQues.append("|").append(to_string(devisor / intNum));

             }

             return tpQues;

         }

         else

         {

             tpQues = to_string(CalcStr(inQues));

             for (int i = ; i <  - precise; i++)

                 tpQues.pop_back();

             if (precise == )

                 tpQues.pop_back();

             return tpQues;

         }

     }

     //if not fraction

     else {

         tpQues = to_string(CalcStr(inQues));

         for (int i = ; i <  - precise; i++)//set precise

             tpQues.pop_back();

         if (precise == )

             tpQues.pop_back();

         return tpQues;

     }

 }

 //get questions

 vector<string> questionCore::getQues() {

     vector<string> originQues;

     vector<questionNode*> judgedQues;

     vector<string> finalQues, tempQues;

     originQues = generateQue( * quesNum);

     //generate 10 times questions and choose 1/10 from them

     /*for (int i = 0; i < originQues.size()-1; i++) {

     if (originQues[i].find("^("))

     for (int j = i; j < originQues.size() - 2; j++)

     originQues[j] = originQues[j + 1];

     }*/

     /*for (vector<string>::iterator it = originQues.begin();it != originQues.end();)

     {

     if ((*it).find("^("))

     //删除指定元素，返回指向删除元素的下一个元素的位置的迭代器

     it = originQues.erase(it);

     else

     //迭代器指向下一个元素位置

     ++it;

     }*/

     generateTree(originQues);

     judgeTree();//build and judge

     for (int i = ; i < questions.size(); i++)

     {

         if (fitFlag[i] == true)

             judgedQues.push_back(questions[i]);

     }

     finalQues = quesToStr(judgedQues);

     for (int i = ; i < finalQues.size(); i++)

     {

         Answer.push_back(Calc(finalQues[i]));

     }

     //add ' ' between ops and nums

     string strTmp;

     for (int i = ; i < finalQues.size(); i++)

     {

         strTmp = finalQues[i];

         for (int j = ; j < strTmp.size(); j++)

         {

             if (strTmp[j] == '|'&&fracFlag == true)    continue;

             else if (isOp(strTmp[j]) && strTmp[j] != '('&&strTmp[j] != ')')

             {

                 strTmp.insert(j, , ' ');

                 strTmp.insert(j + , , ' ');

                 j += ;

             }

         }//for

         finalQues[i] = strTmp;

     }//for

     return finalQues;

 }

 //get answers

 vector<string> questionCore::getAns() {

     return Answer;

 }

 //setting

 bool questionCore::setting(int queNum = , int maxOpnum = , int MinR = , int MaxR = , string op = "+-*/^", bool fraction = true, int preci = , string QPath = "Questions.txt", string APath = "Answers.txt")

 {

     quesNum = queNum;

     maxOpNum = maxOpnum;

     minRange = MinR;

     range = MaxR;

     ops.clear();

     for (int i = ; i < op.size(); i++)

     {

         ops.push_back(op[i]);

     }

     fracFlag = fraction;

     precise = preci;

     QuePath = QPath;

     AnsPath = APath;

     setOps();

     return true;

 }

 //add ( ) into ops . if fraction, add function

 void questionCore::setOps() {

     if (fracFlag)

         ops.insert(ops.end(), '|');

     ops.insert(ops.end(), , '(');

     ops.insert(ops.end(), , ')');

 }

 //getResultFile, output Questions.txt , Answers.txt

 void questionCore::getResultFile() {

     vector<string> Ques = getQues();

     vector<string> Ans = getAns();

     ofstream foutQues;

     foutQues.open(QuePath, ios::out);

     for (int i = ; i < Ques.size(); i++) {

         foutQues << Ques[i] << endl;

     }

     foutQues.close();

     ofstream foutAns;

     foutAns.open(AnsPath, ios::out);

     for (int i = ; i < Ans.size(); i++) {

         foutAns << Ans[i] << endl;

     }

     foutAns.close();

     Clear();

 }

question.cpp

 #include "question.h"

 using namespace std;

 int main()

 {

     questionCore Work();

     Work.setting(, , , , "+-*/^", true, );//num of questions, num of ops, min of nums, max of nums, ops(+-*/^), if need fraction, precise

                                                    // int                int            int            int          string            bool            int

     Work.getResultFile();

     return ;

 }

main.cpp

函数前均已写明功能，实现过程并不算复杂，变量名调整得更易读了。

四、测试

　　测试环节由我们2人分工，各自出样例导入setting，观察输出函数结果的情况。有一次结果中突然多了一些负数，我debug半天百思不得其解，队友却很快提醒我：我把CalNum函数中变量的先后顺序搞错了，运算数与被运算数换了位置。这让我节省了非常多的时间。经过重重磨难，我们相互督促、相互鼓励，终于将大部分功能基本完成，需要学习dll等待对接。cpp转dll可以说是我遇见过的最坑的博客问题群，各博主们都在教“一加一”，却没有一份教程详细告诉我们成型的cpp和h文件要怎么转换为dll。因此，我们又花费了大量时间摸索dll文件的制作，比其他组慢了一拍。最后，还是组里的一位同学给了我们帮助，让我们得以从繁琐蒙蔽的dll误导中走出来。今后有空，我要写一份真正有用的cpp转dll博客，不让这样的悲剧再发生。

　　对接时，我们先找了组里的一队UI，面对面对接，但他的QT似乎有点问题，经过他一段时间的升级编译器后，我们总算有惊无险地对接成功。随后，我们将头文件、dll和lib文件和API文档保存在压缩文件中，发布到群里，目前它正在等待可爱善良帅气大方好心的UI组宠幸。

五、结对

　　①结对编程在这次作业中最直接的好处就是干的活少了，一起讨论、设计完函数后可以共同实现、轮班，相互测试，完成效率比较高。同时，由于一人编码、一人监督，bug率大大降低，有一次我的if函数中犯了个很低级的逻辑错误，立马就被队友机智地识破并指出，省去了巨大的debug时间开销。

　　②从这次结对中，我学到了敢于担当、积极进取的精神，学会了与他人一同合作、共同开发软件，也发现了自己知识层面的许多不足，需要继续努力。

　　③今后工作中若有机会，我会选择结对编程。

　　　　　　　　　　　　　　　　　　　图为我帮队友同步审核代码

六、总结反思

　　本次结对编程中的收获上文中也说得差不多了，补充一点：学到了dll的相关知识且打算抽空写一篇cpp转dll攻略。总的来说还有一些做得不够好的地方，比如接口的设计除了兼容文件输入、字符串输入外，还能更加人性化一点、增加更多功能方便UI组调用等等，但由于时间确实紧张，没能实现多少。

　　对于这门课的看法，我认为这门课确实比较锻炼动手能力，但很多时候一些通知和需求下发得比较晚，任务也比较重，对我们的负担还是相当大的。在有个人作业、结对作业的周，我根本没有时间去碰我们的团队作业，还一定程度上影响了我正常的课业学习。但总体而言，我还是比较喜欢这门课的，希望以后的团队作业中，我们组能同心协力、共创佳绩。

巴特西

现代软件工程HW2：结对编程-生成五则运算式-Core10组 [PB16110698+PB16120162]

最新文章

热门文章