四則運算2開發簡介

??? 四則運算2在四則運算1的基礎之上，又添加了新的功能，但是我覺得四則運算2的難度比四則運算1增大了很多，我在編程的過程中，遇到的最大難度就是不知該如何更好的融合各個功能之間的關系。

??? 寫到現在，四則運算2主要實現了以下幾個功能：

??? 1.題目可不重復

??? 2.打印方式可以選擇，既可以在屏幕上輸出，又可以保存到文件

??? 3.題目的數量可以由用戶控制

??? 4.可以設置四則運算的數值范圍

??? 5.可以實現運算式中有無乘除法

??? 6.可以支持十個數參與運算，并且通過括號改變運算的優先級

??? 7.有除法算式的情況下，可以實現整數除法的整除運算，不產生余數

??? 8.加減法可以實現無負數參與運算

??? 根據程序實現的功能，對程序的設計思想簡介如下：

??? 1.為保證題目的不重復，在產生隨機數時加入了判斷語句，將當下產生的隨機數與以前產生的隨機數作比較，如果重復了，則當下的隨機數舍棄，重新生成，重新生成后接著比較，直到產生新的不重復的隨機數才繼續往下執行。

??? 2.打印方式分為在屏幕上輸出與保存至文件兩項，保存到文件的程序功能與輸出到屏幕的程序功能一致，在輸出到文件時，定義了一個txt文檔，用文件輸出流將最后的結果輸出到文件保存。

??? 3.程序開始會讓用戶設置某些參數，通過定義全局變量的形式，保存用戶輸入的運算式數量，從而控制產生的運算式數量。

??? 4.設置數值范圍與設置數量的方式一樣，也定義了全局變量。

??? 5.乘除法的實現是用隨機數控制的，只產生0和1兩個隨機數，再加上switch語句就可以實現只有加減兩種運算。

??? 6.利用隨機函數生成3-10的一個隨機數，這個隨機數代表了多項式四則運算中的因子個數，然后分別產生這些隨機數和比運算數少一的運算符，比較后一個運算符和前一個運算符的優先級，若后一個運算符的優先級比前一個高，即后面的運算為乘除，則將前一個算式用括號括起來，保證了加減運算可以實現。

??? 7.多項式運算沒有實現沒有余數，兩個整數參與運算時，可以保證整除，分數除法考慮是否能夠整除無意義

??? 8.當數值范圍定義中含有負數范圍時，程序會提示用戶再次輸入范圍，即若最小值小于零，則不能保證每一個加數都是大于零的，則需用戶再次輸入范圍，重新生成隨機數。

??? 程序源代碼如下所示：

  1 //四則運算程序2,從四則運算程序1的基礎之上進行功能擴展
  2 //支持真分數運算，題目不重復,最多可支持十個運算數的帶括號的運算式
  3 //多項四則運算式以及分數除法未予考慮余數，整數除法可以實現整除功能
  4 //2016,03,09
  5 
  6 #include<iostream>
  7 #include<fstream>
  8 #include<stdlib.h>
  9 #include<time.h>
 10 using namespace std;
 11 
 12 void main()
 13 {
 14     srand((int)time(NULL));
 15     //定義變量，記錄用戶的功能選擇選項
 16     int minfigure;
 17     int maxfigure;
 18     int count;
 19     int chengchu;
 20     int remainder_chengchu;
 21     int negative_jiajian;
 22     int printstyle;
 23     //功能設置界面
 24     cout << "*******************************************************************" << endl;
 25     cout << "*                         四則運算生成器                          *" << endl;
 26     cout << "*******************************************************************" << endl;
 27     cout << "請按照系統提示設置生成器的功能：" << endl;
 28     cout << "請輸入參與四則運算的數值范圍(格式如：1  100)：" ;
 29     cin >> minfigure >> maxfigure;
 30     cout << "請輸入生成四則運算式的數量：";
 31     cin >> count;
 32     cout << "請選擇打印方式（1 屏幕輸出  0 輸出到文檔）：";
 33     cin >> printstyle;
 34     cout << "請設置系統的下列參數：" << endl;
 35     cout << "    1 四則運算可否生成乘除法（1 是  0 否）：";
 36     cin >> chengchu;
 37     if (1 == chengchu)
 38     {
 39         cout << "    2 除法是否可有余數（1 是  0 否）：";
 40         cin >> remainder_chengchu;
 41     }
 42     else
 43     {
 44         cout << "    2 加減法是否可以有負數（1 是  0 否）：";
 45         cin >> negative_jiajian;
 46     }
 47     cout << "功能設置完成！" << endl;
 48     cout << "*******************************************************************" << endl;
 49 
 50     int i, j;
 51     int A[100];
 52     int B[100];
 53     int mark[9];
 54     int Operator[10];
 55     char operatorFu[9];
 56     int Operatorfu[9];
 57     //生成用戶指定數量的運算式的因子，為保證算式不重復，讓生成的隨機數都不重復
 58     for (i = 0; i < count; i++)
 59     {
 60         A[i] = minfigure + rand() % maxfigure;
 61         B[i] = minfigure + rand() % maxfigure;
 62         for (j = 0; j < i; j++)
 63         {
 64             if (A[i] == A[j])
 65             {
 66                 A[i] = minfigure + rand() % maxfigure;
 67                 j = 0;
 68             }
 69             if (B[i] == B[j])
 70             {
 71                 B[i] = minfigure + rand() % maxfigure;
 72                 j = 0;
 73             }
 74         }
 75     }
 76     //根據用戶的選擇產生功能分支
 77     if (1 == printstyle)   //運算式輸出到屏幕上
 78     {
 79         if (1 == chengchu)  //是否可以生成除法
 80         {
 81             if (remainder_chengchu)  //除法可否有余數，分數除法談論是否有余數無意義
 82             {
 83                 cout << "*******************************************************************" << endl;
 84                 cout << "生成的四則運算式如下所示：" << endl;
 85                 cout << "*******************************************************************" << endl;
 86                 for (i = 0; i < count; i++)
 87                 {
 88                     if (A[i] > B[i])   //如果A[i]>B[i],則后續程序生成帶括號的多項因子的四則運算
 89                     {
 90                         int m;
 91                         int operator_count = 3 + rand() % 8;   //隨機生成多項因子的個數
 92                         int operatorfu_count = operator_count - 1;  //算符的個數比因子的個數少一
 93                         for (m = 0; m < operator_count; m++)
 94                         {
 95                             Operator[m] = minfigure + rand() % maxfigure;   //生成多項因子
 96                         }
 97                         for (m = 0; m < operatorfu_count; m++)
 98                         {
 99                             Operatorfu[m] = rand() % 4;                  //生成多項式的算符
100                         }
101                         for (m = 1; m < operator_count; m++)
102                         {
103                             if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))  //乘除用3和4表示，加減用1和2表示，讓其除以二得商0和1，可以區分出乘除為同一優先級，加減比乘除優先級低
104                             {                                                 //若后一個運算符的優先級比前一個運算符的優先級高，則將前一個運算符對應的式子用括號括起來，確保了運算優先級低的加減運算在括號里面
105                                 switch (Operatorfu[m - 1])
106                                 {
107                                 case 0:
108                                     cout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
109                                 case 1:
110                                     cout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
111                                 case 2:
112                                     cout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
113                                 case 3:
114                                     if (0 == Operator[m])
115                                     {
116                                         cout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
117                                     }
118                                     break;   //若分子為零時，則讓分子加2，即除以2
119                                 }
120                                 switch (Operatorfu[m])
121                                 {
122                                 case 0:
123                                     cout << " + "; m = m + 1; break;
124                                 case 1:
125                                     cout << " - "; m = m + 1; break;
126                                 case 2:
127                                     cout << " x "; m = m + 1; break;
128                                 case 3:
129                                     cout << " ÷ "; m = m + 1; break;
130                                 }
131                             }
132                             else
133                             {
134                                 switch (Operatorfu[m - 1])
135                                 {
136                                 case 0:
137                                     cout << Operator[m - 1] << " + "; break;
138                                 case 1:
139                                     cout << Operator[m - 1] << " - "; break;
140                                 case 2:
141                                     cout << Operator[m - 1] << " x "; break;
142                                 case 3:
143                                     cout << Operator[m - 1] << " ÷ "; break;
144                                 }
145                             }
146                         }
147                         cout << Operator[m - 1] << " = " << endl;         //輸出最后一個多項式因子
148                     }
149                     else            //如果A[i]<B[i],則產生真分數運算式
150                     {
151                         int copyA = A[i];
152                         int copyB = B[i];
153                         int beichushuA = maxfigure;
154                         int beichushuB = maxfigure;
155                         int firstA = beichushuA% copyA;
156                         int firstB = beichushuB% copyB;
157                         while (firstA != 0)        //求A[i]和最大值的公約數，以便后面化簡
158                         {
159                             int temp = copyA;
160                             copyA = beichushuA%copyA;
161                             beichushuA = temp;
162                             firstA = beichushuA%copyA;
163                         }
164                         while (firstB != 0)
165                         {
166                             int temp = copyB;
167                             copyB = beichushuB%copyB;
168                             beichushuB = temp;
169                             firstB = beichushuB%copyB;
170                         }
171                         int suanfu = rand() % 4;
172                         switch (suanfu)
173                         {
174                         case 0:
175                             cout << A[i] / copyA << "/" << maxfigure / copyA << " + " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
176                         case 1:
177                             cout << A[i] / copyA << "/" << maxfigure / copyA << " - " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
178                         case 2:
179                             cout << A[i] / copyA << "/" << maxfigure / copyA << " x " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
180                         case 3:
181                             cout << A[i] / copyA << "/" << maxfigure / copyA << " ÷ " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
182                             //讓A[i]和最大值都除以公約數便可以得到無法再約分的最大公約數
183                         }
184                     }
185                 }
186             }
187             else
188             {
189                 cout << "*******************************************************************" << endl;
190                 cout << "生成的四則運算式如下所示：" << endl;
191                 cout << "*******************************************************************" << endl;
192                 for (i = 0; i < count; i++)
193                 {
194                     if (A[i] > B[i])
195                     {
196                         int m;
197                         int operator_count = 3 + rand() % 8;
198                         int operatorfu_count = operator_count - 1;
199                         for (m = 0; m < operator_count; m++)
200                         {
201                             Operator[m] = minfigure + rand() % maxfigure;
202                         }
203                         for (m = 0; m < operatorfu_count; m++)
204                         {
205                             Operatorfu[m] = rand() % 4;
206                         }
207                         for (m = 1; m < operator_count; m++)
208                         {
209                             if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))
210                             {
211                                 switch (Operatorfu[m - 1])
212                                 {
213                                 case 0:
214                                     cout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
215                                 case 1:
216                                     cout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
217                                 case 2:
218                                     cout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
219                                 case 3:
220                                     if (0 == Operator[m])
221                                     {
222                                         cout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
223                                     }
224                                     break;
225                                 }
226                                 switch (Operatorfu[m])
227                                 {
228                                 case 0:
229                                     cout << " + "; m = m + 1; break;
230                                 case 1:
231                                     cout << " - "; m = m + 1; break;
232                                 case 2:
233                                     cout << " x "; m = m + 1; break;
234                                 case 3:
235                                     cout << " ÷ "; m = m + 1; break;
236                                 }
237                             }
238                             else
239                             {
240                                 switch (Operatorfu[m - 1])
241                                 {
242                                 case 0:
243                                     cout << Operator[m - 1] << " + "; break;
244                                 case 1:
245                                     cout << Operator[m - 1] << " - "; break;
246                                 case 2:
247                                     cout << Operator[m - 1] << " x "; break;
248                                 case 3:
249                                     cout << Operator[m - 1] << " ÷ "; break;
250                                 }
251                             }
252                         }
253                         cout << Operator[m - 1] << " = " << endl;
254                     }
255                     else
256                     {
257                         int copyB = B[i];
258                         int first = B[i] % A[i];
259                         while (first != 0)
260                         {
261                             int temp = A[i];
262                             A[i] = B[i] % A[i];
263                             B[i] = temp;
264                             first = B[i] % A[i];
265                         }
266                         int suanfu = rand() % 4;
267                         switch (suanfu)
268                         {
269                         case 0:
270                             cout << A[i] << " + " << B[i] << "=" << endl; break;
271                         case 1:
272                             cout << A[i] << " - " << B[i] << "=" << endl; break;
273                         case 2:
274                             cout << A[i] << " x " << B[i] << "=" << endl; break;
275                         case 3:
276                             cout << copyB << " ÷ " << A[i] << " = " << endl; break;
277                         }
278                     }
279                 }
280             }
281         }
282         else   //不允許生成乘除法，則只有加減法
283         {
284             if ((minfigure < 0) && (0 == negative_jiajian))  //若加減法不允許出現負數，則應該重新設定數值的范圍，讓最小值大于零，保證生成的隨機數都是大于零的
285             {
286                 cout << "請重新設置數值范圍，最小值應大于零以保證加法無負數！" << endl;
287                 cout << "請輸入參與四則運算的數值范圍(格式如：1  100)：";
288                 cin >> minfigure >> maxfigure;
289                 for (i = 0; i < count; i++)     //重新生成的隨機數仍是不重復的
290                 {
291                     A[i] = minfigure + rand() % maxfigure;
292                     B[i] = minfigure + rand() % maxfigure;
293                     for (j = 0; j < i; j++)
294                     {
295                         if (A[i] == A[j])
296                         {
297                             A[i] = minfigure + rand() % maxfigure;
298                             j = 0;
299                         }
300                         if (B[i] == B[j])
301                         {
302                             B[i] = minfigure + rand() % maxfigure;
303                             j = 0;
304                         }
305                     }
306                 }
307             }
308             for (i = 0; i < count; i++)
309             {
310                 if (A[i]>B[i])
311                 {
312                     int suanfu = rand() % 2;
313                     switch (suanfu)
314                     {
315                     case 0:
316                         cout << A[i] << " + " << B[i] << "=" << endl; break;
317                     case 1:
318                         cout << A[i] << " - " << B[i] << "=" << endl; break;
319                     }
320                 }
321                 else
322                 {
323                     int copyA = A[i];
324                     int copyB = B[i];
325                     int beichushuA = maxfigure;
326                     int beichushuB = maxfigure;
327                     int firstA = beichushuA% copyA;
328                     int firstB = beichushuB% copyB;
329                     while (firstA != 0)
330                     {
331                         int temp = copyA;
332                         copyA = beichushuA%copyA;
333                         beichushuA = temp;
334                         firstA = beichushuA%copyA;
335                     }
336                     while (firstB != 0)
337                     {
338                         int temp = copyB;
339                         copyB = beichushuB%copyB;
340                         beichushuB = temp;
341                         firstB = beichushuB%copyB;
342                     }
343                     int suanfu = rand() % 2;
344                     switch (suanfu)
345                     {
346                     case 0:
347                         cout << A[i] / copyA << "/" << maxfigure / copyA << " + " << B[i] / copyB << "/" << maxfigure / copyB << "=" << endl; break;
348                     case 1:
349                         cout << B[i] / copyB << "/" << maxfigure / copyB << " - " << A[i] / copyA << "/" << maxfigure / copyA << "=" << endl; break;
350                     }
351                 }
352             }
353         }
354     }
355     else  //將最后生成的四則運算式存到文件中，內部實現的功能與輸出到屏幕一致，只是輸出不一樣
356     {
357         if (1 == chengchu)
358         {
359             if (remainder_chengchu)
360             {
361                 ofstream fileout;  //定義輸出文件流的對象
362                 fileout.open("biaodashi.txt", ios::out);  //打開文件，該文件為指定路徑，則存放在工程的當前目錄下
363                 fileout << "*******************************************************************" << endl;
364                 fileout << "生成的四則運算式如下所示：" << endl;
365                 fileout << "*******************************************************************" << endl;
366                 for (i = 0; i < count; i++)
367                 {
368                     if (A[i] > B[i])
369                     {
370                         int m;
371                         int operator_count = 3 + rand() % 8;
372                         int operatorfu_count = operator_count - 1;
373                         for (m = 0; m < operator_count; m++)
374                         {
375                             Operator[m] = minfigure + rand() % maxfigure;
376                         }
377                         for (m = 0; m < operatorfu_count; m++)
378                         {
379                             Operatorfu[m] = rand() % 4;
380                         }
381                         for (m = 1; m < operator_count; m++)
382                         {
383                             if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))
384                             {
385                                 switch (Operatorfu[m - 1])
386                                 {
387                                 case 0:
388                                     fileout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
389                                 case 1:
390                                     fileout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
391                                 case 2:
392                                     fileout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
393                                 case 3:
394                                     if (0 == Operator[m])
395                                     {
396                                         fileout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
397                                     }
398                                     break;
399                                 }
400                                 switch (Operatorfu[m])
401                                 {
402                                 case 0:
403                                     fileout << " + "; m = m + 1; break;
404                                 case 1:
405                                     fileout << " - "; m = m + 1; break;
406                                 case 2:
407                                     fileout << " x "; m = m + 1; break;
408                                 case 3:
409                                     fileout << " ÷ "; m = m + 1; break;
410                                 }
411                             }
412                             else
413                             {
414                                 switch (Operatorfu[m - 1])
415                                 {
416                                 case 0:
417                                     fileout << Operator[m - 1] << " + "; break;
418                                 case 1:
419                                     fileout << Operator[m - 1] << " - "; break;
420                                 case 2:
421                                     fileout << Operator[m - 1] << " x "; break;
422                                 case 3:
423                                     fileout << Operator[m - 1] << " ÷ "; break;
424                                 }
425                             }
426                         }
427                         fileout << Operator[m - 1] << " = " << endl;
428                     }
429                     else
430                     {
431                         int copyA = A[i];
432                         int copyB = B[i];
433                         int beichushuA = maxfigure;
434                         int beichushuB = maxfigure;
435                         int firstA = beichushuA% copyA;
436                         int firstB = beichushuB% copyB;
437                         while (firstA != 0)
438                         {
439                             int temp = copyA;
440                             copyA = beichushuA%copyA;
441                             beichushuA = temp;
442                             firstA = beichushuA%copyA;
443                         }
444                         while (firstB != 0)
445                         {
446                             int temp = copyB;
447                             copyB = beichushuB%copyB;
448                             beichushuB = temp;
449                             firstB = beichushuB%copyB;
450                         }
451                         int suanfu = rand() % 4;
452                         switch (suanfu)
453                         {
454                         case 0:
455                             fileout << A[i] / copyA << "/" << maxfigure / copyA << " + " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
456                         case 1:
457                             fileout << A[i] / copyA << "/" << maxfigure / copyA << " - " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
458                         case 2:
459                             fileout << A[i] / copyA << "/" << maxfigure / copyA << " x " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
460                         case 3:
461                             fileout << A[i] / copyA << "/" << maxfigure / copyA << " ÷ " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
462                         }
463                     }
464                 }
465                 fileout.close();   //關閉文件，斷開與文件連接
466             }
467             else
468             {
469                 ofstream fileout;
470                 fileout.open("biaodashi.txt", ios::out);
471                 fileout << "*******************************************************************" << endl;
472                 fileout << "生成的四則運算式如下所示：" << endl;
473                 fileout << "*******************************************************************" << endl;
474                 for (i = 0; i < count; i++)
475                 {
476                     if (A[i] > B[i])
477                     {
478                         int m;
479                         int operator_count = 3 + rand() % 8;
480                         int operatorfu_count = operator_count - 1;
481                         for (m = 0; m < operator_count; m++)
482                         {
483                             Operator[m] = minfigure + rand() % maxfigure;
484                         }
485                         for (m = 0; m < operatorfu_count; m++)
486                         {
487                             Operatorfu[m] = rand() % 4;
488                         }
489                         for (m = 1; m < operator_count; m++)
490                         {
491                             if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))
492                             {
493                                 switch (Operatorfu[m - 1])
494                                 {
495                                 case 0:
496                                     fileout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
497                                 case 1:
498                                     fileout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
499                                 case 2:
500                                     fileout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
501                                 case 3:
502                                     if (0 == Operator[m])
503                                     {
504                                         fileout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
505                                     }
506                                     break;
507                                 }
508                                 switch (Operatorfu[m])
509                                 {
510                                 case 0:
511                                     fileout << " + "; m = m + 1; break;
512                                 case 1:
513                                     fileout << " - "; m = m + 1; break;
514                                 case 2:
515                                     fileout << " x "; m = m + 1; break;
516                                 case 3:
517                                     fileout << " ÷ "; m = m + 1; break;
518                                 }
519                             }
520                             else
521                             {
522                                 switch (Operatorfu[m - 1])
523                                 {
524                                 case 0:
525                                     fileout << Operator[m - 1] << " + "; break;
526                                 case 1:
527                                     fileout << Operator[m - 1] << " - "; break;
528                                 case 2:
529                                     fileout << Operator[m - 1] << " x "; break;
530                                 case 3:
531                                     fileout << Operator[m - 1] << " ÷ "; break;
532                                 }
533                             }
534                         }
535                         fileout << Operator[m - 1] << " = " << endl;
536                     }
537                     else
538                     {
539                         int copyB = B[i];
540                         int first = B[i] % A[i];
541                         while (first != 0)
542                         {
543                             int temp = A[i];
544                             A[i] = B[i] % A[i];
545                             B[i] = temp;
546                             first = B[i] % A[i];
547                         }
548                         int suanfu = rand() % 4;
549                         switch (suanfu)
550                         {
551                         case 0:
552                             fileout << A[i] << " + " << B[i] << "=" << endl; break;
553                         case 1:
554                             fileout << A[i] << " - " << B[i] << "=" << endl; break;
555                         case 2:
556                             fileout << A[i] << " x " << B[i] << "=" << endl; break;
557                         case 3:
558                             fileout << copyB << " ÷ " << A[i] << " = " << endl; break;
559                         }
560                     }
561                 }
562                 fileout.close();
563             }
564         }
565         else
566         {
567             if ((minfigure < 0) && (0 == negative_jiajian))
568             {
569                 cout << "請重新設置數值范圍，最小值應大于零以保證加法無負數！" << endl;
570                 cout << "請輸入參與四則運算的數值范圍(格式如：1  100)：";
571                 cin >> minfigure >> maxfigure;
572                 for (i = 0; i < count; i++)
573                 {
574                     A[i] = minfigure + rand() % maxfigure;
575                     B[i] = minfigure + rand() % maxfigure;
576                     for (j = 0; j < i; j++)
577                     {
578                         if (A[i] == A[j])
579                         {
580                             A[i] = minfigure + rand() % maxfigure;
581                             j = 0;
582                         }
583                         if (B[i] == B[j])
584                         {
585                             B[i] = minfigure + rand() % maxfigure;
586                             j = 0;
587                         }
588                     }
589                 }
590             }
591             ofstream fileout;
592             fileout.open("biaodashi.txt", ios::out);
593             for (i = 0; i < count; i++)
594             {
595                 if (A[i]>B[i])
596                 {
597                     int suanfu = rand() % 2;
598                     switch (suanfu)
599                     {
600                     case 0:
601                         fileout << A[i] << " + " << B[i] << "=" << endl; break;
602                     case 1:
603                         fileout << A[i] << " - " << B[i] << "=" << endl; break;
604                     }
605                 }
606                 else
607                 {
608                     int copyA = A[i];
609                     int copyB = B[i];
610                     int beichushuA = maxfigure;
611                     int beichushuB = maxfigure;
612                     int firstA = beichushuA% copyA;
613                     int firstB = beichushuB% copyB;
614                     while (firstA != 0)
615                     {
616                         int temp = copyA;
617                         copyA = beichushuA%copyA;
618                         beichushuA = temp;
619                         firstA = beichushuA%copyA;
620                     }
621                     while (firstB != 0)
622                     {
623                         int temp = copyB;
624                         copyB = beichushuB%copyB;
625                         beichushuB = temp;
626                         firstB = beichushuB%copyB;
627                     }
628                     int suanfu = rand() % 2;
629                     switch (suanfu)
630                     {
631                     case 0:
632                         fileout << A[i] / copyA << "/" << maxfigure / copyA << " + " << B[i] / copyB << "/" << maxfigure / copyB << "=" << endl; break;
633                     case 1:
634                         fileout << B[i] / copyB << "/" << maxfigure / copyB << " - " << A[i] / copyA << "/" << maxfigure / copyA << "=" << endl; break;
635                     }
636                 }
637             }
638             fileout.close();
639         }
640     }
641 }

??? 運行結果截圖如下所示：

???

??? 項目計劃總結表：

周活動總結表????????????????????? 日期：2016年3月12日
日期\任務	聽課	編寫程序	閱讀課本	日總結
周一 3.7	2	1	1	4
周二 3.8	?	?	?	?
周三 3.9	?	2	1	3
周四 3.10	2	?	1	3
周五 3.11	?	3	?	3
周六 3.12	?	8	?	8
周日 3.13	?	?	?	?
周總計	4	14	3	21

??? 時間記錄日志：???

日期	開始時間	結束時間	中斷時間	凈時間	活動	備注
3.7	14：00	16:00	?	2	聽課，改程序	?
?	20：00	21：00	?	1	看課本	?
?	21：20	22:20	?	1	寫程序	?
3.8	?	?	?	?	?	?
3.9	14：30	18：00	0.5	3	寫程序，看課本	洗衣服
3.10	19：00	22：00	?	3	上課，看書	?
3.11	19：00	22：00	?	3	寫程序	?
3.12	8：00	12：00	?	4	寫程序	?
?	13：00	17：00	?	4	寫程序	?
3.13	?	?	?	?	?	?

??? 缺陷記錄日志：

日期	編號	類型	引入階段	排除階段	修復時間	修復缺陷
3.7	1	?	編譯	編譯	5min	?
3.7	描述：for循環中的循環條件不對
3.8	?	?	?	?	?	?
3.8	?	?	?	?	?	?
3.9	2	?	編碼	編碼	1min	?
3.9	描述：if和else不匹配
3.10	?	?	?	?	?	?
3.10	?	?	?	?	?	?
3.11	3	?	編碼	編碼	2h	?
3.11	描述：主程序邏輯結構不正確
3.12	4	?	編碼	編碼	3h	?
3.12	描述：邏輯功能嵌套不完善