四则运算之Right-BICEP单元测试

一、

这篇博客要对上次实现的四则运算进行单元测试，一是检查上次的程序的实现情况，二是巩固单元测试的相关知识。本次进行单元测试用的是Riget-BICEP方法。

Riget-BICEP方法：

1、Right－结果是否正确？
            2、B－是否所有的边界条件都是正确的？
            3、I－能查一下反向关联吗？
            4、C－能用其他手段交叉检查一下结果吗？
            5、E－你是否可以强制错误条件发生？
            6、P－是否满足性能要求？

对应于以上的六个值得测试的部位，选择适合本程序的测试方法进行测试如下：

1、运算式多少的测试：分为运算式个数比较少和运算式比较多两种情况，看看结果如何

首先是5个运算式：运行时间较快

运算式数量增加为300个：运算时间较长

运算出现错误，错误为求余数是，方程rand()%a中，a出现负数的情况。经过对a的不同值的判断处理，修改程序后，结果为：

2、控制能否有乘除法

没有的情况：

有的情况：

3、控制是否能有有负数出现

不能有负数出现;

4、测试能否有余数出现

不能有余数出现：

5、测试可以有括号生成

6、测试能否输出运算式到文件：

二、根据代码风格规范修改后的程序为

 //第三次实验
 #include<iostream>
 #include<string>
 #include<stdlib.h>
 #include<time.h>
 #include<math.h>
 #include<fstream>
 using namespace std;

 int main()
 {
     int intExpressieCanYu[][];         //这是一个二维数组，每行记录的是每个运算式中参与的数字
     int intExpressieNumNum[];            //此数组记录二维数组相应行中的列数，及记录每个运算式中参与运算的数字的个数
     int intNumber;              //定义产生的运算式中数的数量(最大为10个数)
     int intExpressieNum;       //定义产生的运算式的数量
     int intPrintStyle;          //定义打印方式（DOS界面打印、输出到文件）
     int intMultiplyDivide;     //定义是否有乘除法，0代表没有，1代表有
     int intMax, min;            //定义四则运算中的数的取值范围
     int intMinus;               //定义是否有负数，0代表没有，1代表有
     int intRemainder;           //定义是否有余数，0代表没有，1代表有
     int intBracket;             //定义是否有括号，0代表没有，1代表有

     int intBiaozhiwei[];       //标志位，记录各个条件

     cout << "请输入要生成的运算式的数量：";
     cin >> intExpressieNum;
     cout << endl;
     cout << "请输入打印运算式的方式（0代表DOS界面，1代表输出到文件）：";
     cin >> intPrintStyle;
     cout << endl;
     cout << "运算式中是否含有乘除法（0代表没有，1代表有）：";
     cin >> intMultiplyDivide;
     cout << endl;
     cout << "请输入运算式中数的取值范围（输入方式为：最小值 空格 最大值）：";
     cin >> min >> intMax;
     cout << endl;
     cout << "运算过程能否出现负数（0代表不能，1代表能）";
     cin >> intMinus;
     cout << endl;
     cout << "定义运算过程是否能够有余数出现（0代表不能出现余数，1代表能出现）";
     cin >> intRemainder;
     cout << endl;
     cout << "定义括号是否能够参与运算（0代表不能，1代表能）";
     cin >> intBracket;
     cout << endl;

     intBiaozhiwei[] = intExpressieNum;
     intBiaozhiwei[] = intPrintStyle;
     intBiaozhiwei[] = intMultiplyDivide;
     intBiaozhiwei[] = min;
     intBiaozhiwei[] = intMax;
     intBiaozhiwei[] = intMinus;
     intBiaozhiwei[] = intRemainder;
     intBiaozhiwei[] = intBracket;

     ofstream outfile;
     outfile.open("f1.dat", ios::out);
     //首先根据运算式的数量，生成每个运算式需要的数，并记录在intExpressieCanYu[1000][10]中
     srand((int)time());           //根据时间生成随机数种子
     int xun_huan_expressieNum;      //此变量代表循环时的记录，代表已经循环的次数
     for (xun_huan_expressieNum = ; xun_huan_expressieNum < intExpressieNum; xun_huan_expressieNum++)
     {
         intNumber =  + rand() % ;            //随机生成参与每个式子进行运算的数的个数
         intExpressieNumNum[xun_huan_expressieNum] = intNumber;      //将每个式子中数字的个数存入数组intExpressieNumNum[1000]中

         for (int i = ; i < intNumber; i++)       //根据intNumber生成式子中的每个随机数
         {
             intExpressieCanYu[xun_huan_expressieNum][i] = min + rand() % (intMax - min);    //此处可能有错
         }
     }

     //以上完成了数组的初始化，下面要完成运算式的组装

     srand((int)time(NULL));
     for (int i = ; i < intExpressieNum; i++)           //对N个运算式进行循环
     {

         if ( == intBracket)         //如果没有括号
         {
             int yunsuanfugeshu;      //变量运算符的个数
             yunsuanfugeshu = intExpressieNumNum[i] - ;
             char yunsuanfu[];     //此数组存储运算符

             for (int j = ; j < yunsuanfugeshu; j++)     //对运算符数组进行赋值
             {
                 if ( == intMultiplyDivide)  //如果没有乘除法
                 {
                     int sign_noMD;     //数字代表符号
                     sign_noMD =  + rand() % ;
                     if ( == sign_noMD)
                     {
                         yunsuanfu[j] = '+';
                     }
                     else
                     {
                         yunsuanfu[j] = '-';
                     }
                 }
                 else
                 {
                     int sign_yesMD;     //数字代表运算符，且含有乘除法
                     sign_yesMD =  + rand() % ;
                     if ( == sign_yesMD)
                     {
                         yunsuanfu[j] = '+';
                     }
                     else if ( == sign_yesMD)
                     {
                         yunsuanfu[j] = '-';
                     }
                     else if ( == sign_yesMD)
                     {
                         yunsuanfu[j] = '*';
                     }
                     else if ( == sign_yesMD)
                     {
                         yunsuanfu[j] = '/';
                     }
                 }
             }

             //运算符不能有连续3个为除号
             for (int ai = ; ai < yunsuanfugeshu; ai++)
             {
                 if (yunsuanfu[ai] == '/')
                 {
                     if (yunsuanfu[ai + ] == '/')
                     {
                         if (yunsuanfu[ai + ] == '/')
                         {
                             yunsuanfu[ai + ] = '+';
                         }
                     }
                 }
             }

             //cout << "运算符的个数为：" << yunsuanfugeshu << endl;
             //输出所有运算符号
             /*cout << "所有运算符号为：";
             for (int fuhaoshu1 = 0; fuhaoshu1 < yunsuanfugeshu; fuhaoshu1++)
             {
             cout << yunsuanfu[fuhaoshu1] << " ";
             }
             */
             //上面的循环是对运算符号的赋值。下面组合运算式
             //此时已存在数组intExpressieCanYu[i][0-intNumber](参与运算的数字的个数)，yunsuanfu[10](存储运算符)，yunsuanfugeshu（运算符个数）
             if ( == intMultiplyDivide)  //如果没有乘除法
             {
                 if ( == intMinus)   //如果不能有负数出现
                 {
                     int jieguo;
                     jieguo = intExpressieCanYu[i][];   //结果等于此行数组中的第一个数值

                     //下面的循环是对运算式预算过程有无负数的判断
                     for (int nointMinusNum = ; nointMinusNum < (intExpressieNumNum[i] - ); nointMinusNum++)
                     {
                         if (yunsuanfu[nointMinusNum] == '+')
                         {
                             jieguo = jieguo + intExpressieCanYu[i][nointMinusNum + ];

                         }
                         else
                         {
                             jieguo = jieguo - intExpressieCanYu[i][nointMinusNum + ];
                             if (jieguo <= )
                             {
                                 int a;
                                 a = jieguo;
                                 int b;
                                 b = jieguo + intExpressieCanYu[i][nointMinusNum + ];
                                 if (a < )
                                 {
                                     a = abs(a);
                                     intExpressieCanYu[i][nointMinusNum + ] = b - rand() % (a);
                                 }
                                 if (a == )
                                 {
                                     intExpressieCanYu[i][nointMinusNum + ] = b - rand() % b;
                                 }

                             }
                         }
                     }

                     //对运算式进行输出
                     //cout << "运算式中数的个数为：" << intExpressieNumNum[i] << endl;
                     if ( == intPrintStyle)
                     {
                         int fuhao = ;
                         for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                         {
                             cout << intExpressieCanYu[i][shu];

                             for (; fuhao < yunsuanfugeshu;)
                             {
                                 cout << yunsuanfu[fuhao];
                                 fuhao++;
                                 break;
                             }
                         }
                     }
                     else
                     {

                         int fuhao = ;
                         for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                         {
                             outfile << intExpressieCanYu[i][shu];

                             for (; fuhao < yunsuanfugeshu;)
                             {
                                 outfile << yunsuanfu[fuhao];
                                 fuhao++;
                                 break;
                             }
                         }
                         outfile << endl;
                         //outfile.close();
                     }

                 }
                 else    //如果能有负数出现
                 {
                     //对运算式进行输出
                     //cout << "运算式中数的个数为：" << intExpressieNumNum[i] << endl;
                     if ( == intPrintStyle)
                     {
                         int fuhao = ;
                         for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                         {
                             cout << intExpressieCanYu[i][shu];

                             for (; fuhao < yunsuanfugeshu;)
                             {
                                 cout << yunsuanfu[fuhao];
                                 fuhao++;
                                 break;
                             }
                         }
                     }
                     else
                     {

                         int fuhao = ;
                         for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                         {
                             outfile << intExpressieCanYu[i][shu];

                             for (; fuhao < yunsuanfugeshu;)
                             {
                                 outfile << yunsuanfu[fuhao];
                                 fuhao++;
                                 break;
                             }
                         }
                         outfile << endl;
                         //outfile.close();
                     }
                 }
             }
             else   //如果有乘除法
             {
                 if ( == intRemainder)    //如果不能有余数
                 {
                     int intExpressieCanYu_linshi[];    //建立临时数组，下面的循环为给临时数组赋值
                     for (int linshi_chengchu = ; linshi_chengchu < intExpressieNumNum[i]; linshi_chengchu++)
                     {
                         intExpressieCanYu_linshi[linshi_chengchu] = intExpressieCanYu[i][linshi_chengchu];
                     }
                     char yunsuanfulinshi[];
                     for (int yunsuanfujishu2 = ; yunsuanfujishu2 < yunsuanfugeshu; yunsuanfujishu2++)
                     {
                         yunsuanfulinshi[yunsuanfujishu2] = yunsuanfu[yunsuanfujishu2];
                     }
                     for (int chengchui = ; chengchui < yunsuanfugeshu; chengchui++)  //此循环对数组中的余数情况进行调整
                     {
                         if (yunsuanfulinshi[chengchui] == '*')
                         {
                             int jieguo;
                             jieguo = intExpressieCanYu_linshi[chengchui] * intExpressieCanYu_linshi[chengchui + ];
                             intExpressieCanYu_linshi[chengchui] = jieguo;
                             intExpressieCanYu_linshi[chengchui + ] = jieguo;
                             yunsuanfulinshi[chengchui] = '+';
                         }
                         if (yunsuanfulinshi[chengchui] == '/')
                         {
                             int jieguo;
                             jieguo = intExpressieCanYu_linshi[chengchui] % intExpressieCanYu_linshi[chengchui + ];
                             if (jieguo != )   //如果有余数
                             {
                                 int yueshu = ;//约数
                                 int yushupan = ;
                                 while (yushupan < )
                                 {
                                     int jieguoyue;
                                     jieguoyue = intExpressieCanYu_linshi[chengchui] % yueshu;
                                     if (jieguoyue == )
                                     {
                                         yushupan += ;
                                         if (yushupan == )
                                         {
                                             intExpressieCanYu_linshi[chengchui + ] = yueshu;  //修改临时数组
                                             intExpressieCanYu[i][chengchui + ] = yueshu;       //修改原数组
                                             yunsuanfulinshi[chengchui] = '+';
                                             break;
                                         }
                                     }
                                     yueshu += ;
                                 }
                             }
                         }
                     }

                     if ( == intMinus)  //如果不能有负数
                     {
                         //下面的大循环时修改乘法或除法前面的一个运算符号为加号
                         for (int gaijiahao = ; gaijiahao < yunsuanfugeshu; gaijiahao++)
                         {
                             if (yunsuanfu[gaijiahao] == '*')
                             {
                                 for (int gaijiahao1 = gaijiahao - ; gaijiahao1 >= ; gaijiahao1--)
                                 {
                                     if ((yunsuanfu[gaijiahao1] == '+') || (yunsuanfu[gaijiahao1] == '-'))
                                     {
                                         yunsuanfu[gaijiahao1] = '+';
                                         break;
                                     }
                                 }
                             }
                             if (yunsuanfu[gaijiahao] == '/')
                             {
                                 for (int gaijiahao2 = gaijiahao - ; gaijiahao2 >= ; gaijiahao2--)
                                 {
                                     if ((yunsuanfu[gaijiahao2] == '+') || (yunsuanfu[gaijiahao2] == '-'))
                                     {
                                         yunsuanfu[gaijiahao2] = '+';
                                         if (yunsuanfu[gaijiahao2 + ] == '-')
                                         {
                                             yunsuanfu[gaijiahao2 + ] = '+';
                                         }

                                         break;
                                     }
                                 }
                             }
                         }
                         //以上为修改乘法和除法符号前边的符号+
                         //以下为判断正负
                         for (int fuhaochuan = ; fuhaochuan < yunsuanfugeshu; fuhaochuan++)
                         {
                             if (yunsuanfu[fuhaochuan] == '-')
                             {
                                 intExpressieCanYu[i][fuhaochuan + ] =  + rand() % (intExpressieCanYu[i][fuhaochuan]);
                             }
                         }

                         /*cout << "运算符数组为：";
                         for (int linshia = 0; linshia < yunsuanfugeshu; linshia++)
                         {
                         cout << yunsuanfu[linshia];
                         }
                         cout << endl;*/
                         //对运算式进行输出
                         //cout << "运算式中数的个数为：" << intExpressieNumNum[i] << endl;
                         //修改数组中的负数为1
                         for (int qi = ; qi < intExpressieNumNum[i]; qi++)
                         {
                             if (intExpressieCanYu[i][qi] < )
                             {
                                 intExpressieCanYu[i][qi] = ;
                             }
                         }
                         if ( == intPrintStyle)
                         {
                             int fuhao = ;
                             for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                             {
                                 cout << intExpressieCanYu[i][shu];

                                 for (; fuhao < yunsuanfugeshu;)
                                 {
                                     cout << yunsuanfu[fuhao];
                                     fuhao++;
                                     break;
                                 }
                             }
                         }
                         else
                         {

                             int fuhao = ;
                             for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                             {
                                 outfile << intExpressieCanYu[i][shu];

                                 for (; fuhao < yunsuanfugeshu;)
                                 {
                                     outfile << yunsuanfu[fuhao];
                                     fuhao++;
                                     break;
                                 }
                             }
                             outfile << endl;
                             //outfile.close();
                         }
                     }
                     else    //如果能有负数
                     {
                         //对运算式进行输出
                         //cout << "运算式中数的个数为：" << intExpressieNumNum[i] << endl;
                         if ( == intPrintStyle)
                         {
                             int fuhao = ;
                             for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                             {
                                 cout << intExpressieCanYu[i][shu];

                                 for (; fuhao < yunsuanfugeshu;)
                                 {
                                     cout << yunsuanfu[fuhao];
                                     fuhao++;
                                     break;
                                 }
                             }
                         }
                         else
                         {

                             int fuhao = ;
                             for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                             {
                                 outfile << intExpressieCanYu[i][shu];

                                 for (; fuhao < yunsuanfugeshu;)
                                 {
                                     outfile << yunsuanfu[fuhao];
                                     fuhao++;
                                     break;
                                 }
                             }
                             outfile << endl;
                             //outfile.close();
                         }
                     }
                 }
                 else   //如果可以有余数
                 {
                     if ( == intMinus)  //如果不能有负数
                     {
                         //下面的大循环时修改乘法或除法前面的一个运算符号为加号
                         for (int gaijiahao = ; gaijiahao < yunsuanfugeshu; gaijiahao++)
                         {
                             if (yunsuanfu[gaijiahao] == '*')
                             {
                                 for (int gaijiahao1 = gaijiahao - ; gaijiahao1 >= ; gaijiahao1--)
                                 {
                                     if ((yunsuanfu[gaijiahao1] == '+') || (yunsuanfu[gaijiahao1] == '-'))
                                     {
                                         yunsuanfu[gaijiahao1] = '+';
                                     }
                                 }
                             }
                             if (yunsuanfu[gaijiahao] == '/')
                             {
                                 for (int gaijiahao2 = gaijiahao - ; gaijiahao2 >= ; gaijiahao2--)
                                 {
                                     if ((yunsuanfu[gaijiahao2] == '+') || (yunsuanfu[gaijiahao2] == '-'))
                                     {
                                         yunsuanfu[gaijiahao2] = '+';
                                     }
                                 }
                             }
                         }
                         //以上为修改乘法和除法符号前边的符号+
                         //以下为判断正负
                         for (int fuhaochuan = ; fuhaochuan < yunsuanfugeshu; fuhaochuan++)
                         {
                             if (yunsuanfu[fuhaochuan] == '-')
                             {
                                 intExpressieCanYu[i][fuhaochuan + ] =  + rand() % (intExpressieCanYu[i][fuhaochuan + ]);
                             }
                         }

                         //对运算式进行输出
                         //cout << "运算式中数的个数为：" << intExpressieNumNum[i] << endl;
                         if ( == intPrintStyle)
                         {
                             int fuhao = ;
                             for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                             {
                                 cout << intExpressieCanYu[i][shu];

                                 for (; fuhao < yunsuanfugeshu;)
                                 {
                                     cout << yunsuanfu[fuhao];
                                     fuhao++;
                                     break;
                                 }
                             }
                         }
                         else
                         {

                             int fuhao = ;
                             for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                             {
                                 outfile << intExpressieCanYu[i][shu];

                                 for (; fuhao < yunsuanfugeshu;)
                                 {
                                     outfile << yunsuanfu[fuhao];
                                     fuhao++;
                                     break;
                                 }
                             }
                             outfile << endl;
                             //outfile.close();
                         }
                     }
                     else    //如果能有负数
                     {
                         //对运算式进行输出
                         //cout << "运算式中数的个数为：" << intExpressieNumNum[i] << endl;
                         if ( == intPrintStyle)
                         {
                             int fuhao = ;
                             for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                             {
                                 cout << intExpressieCanYu[i][shu];

                                 for (; fuhao < yunsuanfugeshu;)
                                 {
                                     cout << yunsuanfu[fuhao];
                                     fuhao++;
                                     break;
                                 }
                             }
                         }
                         else
                         {

                             int fuhao = ;
                             for (int shu = ; shu < intExpressieNumNum[i]; shu++)
                             {
                                 outfile << intExpressieCanYu[i][shu];

                                 for (; fuhao < yunsuanfugeshu;)
                                 {
                                     outfile << yunsuanfu[fuhao];
                                     fuhao++;
                                     break;
                                 }
                             }
                             outfile << endl;
                             //outfile.close();
                         }
                     }
                 }

             }
         }
         else   //如果有括号
         {
             //以下各个变量为个数的定义
             int yunsuanfugeshu;      //变量运算符的个数
             yunsuanfugeshu = intExpressieNumNum[i] - ;
             char yunsuanfu[];     //此数组存储运算符

             int zuidakuohaoshu;          //最大括号对数
             if (intExpressieNumNum[i] > )
             {
                 zuidakuohaoshu = intExpressieNumNum[i] - ;
             }
             else
             {
                 zuidakuohaoshu = intExpressieNumNum[i] - ;
             }

             int suijidekuohaoduishu;      //随机的括号的对数
             if (zuidakuohaoshu > )
             {
                 suijidekuohaoduishu =  + rand() % ;
             }
             else
             {
                 suijidekuohaoduishu =  + rand() % zuidakuohaoshu;
             }
             int kuohaogeshu =  * suijidekuohaoduishu;    //总的括号数，不是对数
             char zifushuzu[];          //定义字符数组，存储括号和运算符
             int zifushuzulength = kuohaogeshu + yunsuanfugeshu;     //括号和运算符的总长度

             //对字符数组进行初始化
             for (int chushihua = ; chushihua < ; chushihua++)
             {
                 zifushuzu[chushihua] = 'n';
             }

             //以下循环为运算符数组赋值
             for (int j = ; j < yunsuanfugeshu; j++)     //对运算符数组进行赋值
             {
                 if ( == intMultiplyDivide)  //如果没有乘除法
                 {
                     int sign_noMD;     //数字代表符号
                     sign_noMD =  + rand() % ;
                     if ( == sign_noMD)
                     {
                         yunsuanfu[j] = '+';
                     }
                     else
                     {
                         yunsuanfu[j] = '-';
                     }
                 }
                 else
                 {
                     int sign_yesMD;     //数字代表运算符，且含有乘除法
                     sign_yesMD =  + rand() % ;
                     if ( == sign_yesMD)
                     {
                         yunsuanfu[j] = '+';
                     }
                     else if ( == sign_yesMD)
                     {
                         yunsuanfu[j] = '-';
                     }
                     else if ( == sign_yesMD)
                     {
                         yunsuanfu[j] = '*';
                     }
                     else if ( == sign_yesMD)
                     {
                         yunsuanfu[j] = '/';
                     }
                 }
             }

             //以下将几对括号存入二维数组中
             char kuohaoshuzu[][];
             for (int kuohaojishu = ; kuohaojishu < suijidekuohaoduishu; kuohaojishu++)
             {
                 kuohaoshuzu[kuohaojishu][] = '(';
                 kuohaoshuzu[kuohaojishu][] = ')';
             }

             //对括号二维数组中的每行进行选择，选择在上面定义的字符数组中的位置
             //以下不考虑括号在不在字符数组的首位有两种不同的情况，所以在此不考虑在首位的情况
             srand((int)time());
             for (int erweishuzuhangshu = ; erweishuzuhangshu < suijidekuohaoduishu; erweishuzuhangshu++)
             {
                 int zuosuijishuweizhi;      //此变量代表生成一个随机数，此随机数代表左括号的位置
                 int yousuijishuweizhi;      //此变量代表生成一个随机数，此随机数代表有括号的位置

                 if (zifushuzulength == )
                 {
                     zifushuzu[] = '(';
                     zifushuzu[] = ')';
                 }
                 else
                 {
                     int n1 = , n2 = ;         //退出循环的标记
                     zuosuijishuweizhi =  + rand() % (zifushuzulength - );   //此处可能出错
                     while (n1 != )
                     {
                         if (zifushuzu[zuosuijishuweizhi] == 'n')
                         {
                             zifushuzu[zuosuijishuweizhi] = '(';
                             n1 = ;
                         }
                         else
                         {
                             zuosuijishuweizhi =  + rand() % (zifushuzulength - );
                         }
                     }
                     int aa = zuosuijishuweizhi + ;
                     yousuijishuweizhi = aa + rand() % (zifushuzulength - aa);
                     while (n2 != )
                     {
                         if (zifushuzu[yousuijishuweizhi] == 'n')
                         {
                             zifushuzu[yousuijishuweizhi] = ')';
                             n2 = ;
                         }
                         else
                         {
                             int aa = zuosuijishuweizhi + ;
                             yousuijishuweizhi = aa + rand() % (zifushuzulength - aa);
                         }
                     }
                 }

             }

             //将运算符数组加入到字符数组中
             for (int yunsuanfujishu = ; yunsuanfujishu < yunsuanfugeshu; yunsuanfujishu++)
             {
                 for (int qq = ; qq < zifushuzulength; qq++)
                 {
                     if (zifushuzu[qq] == 'n')
                     {
                         zifushuzu[qq] = yunsuanfu[yunsuanfujishu];
                         break;
                     }
                 }
             }

             //校正字符数组，使得其中不能有相邻的括号
             //下面是校正左括号
             for (int xianlinkuohao = ; xianlinkuohao < (zifushuzulength - ); xianlinkuohao++)
             {
                 if (zifushuzu[xianlinkuohao] == '(' && zifushuzu[xianlinkuohao + ] == ')')
                 {
                     for (int ji = ; ji < zifushuzulength; ji++)
                     {
                         if ((zifushuzu[ji] != '(') && (zifushuzu[ji] != ')') && (zifushuzu[ji + ] != ')') && (zifushuzu[ji - ] != ')'))
                         {
                             char a;
                             a = zifushuzu[ji];
                             zifushuzu[ji] = zifushuzu[xianlinkuohao];
                             zifushuzu[xianlinkuohao] = a;
                             break;
                         }
                     }
                 }
                 if (zifushuzu[xianlinkuohao] == ')' && zifushuzu[xianlinkuohao + ] == '(')
                 {
                     for (int ji = ; ji < zifushuzulength; ji++)
                     {
                         if ((zifushuzu[ji] != '(') && (zifushuzu[ji] != ')') && (zifushuzu[ji + ] != ')') && (zifushuzu[ji - ] != ')'))
                         {
                             char a;
                             a = zifushuzu[ji];
                             zifushuzu[ji] = zifushuzu[xianlinkuohao + ];
                             zifushuzu[xianlinkuohao + ] = a;
                             break;
                         }
                     }
                 }
             }
             //下面是校正右括号
             for (int xianlinkuohao = ; xianlinkuohao < (zifushuzulength - ); xianlinkuohao++)
             {
                 if (zifushuzu[xianlinkuohao] == '(' && zifushuzu[xianlinkuohao + ] == ')')
                 {
                     for (int ji = ; ji < zifushuzulength; ji++)
                     {
                         if ((zifushuzu[ji] != '(') && (zifushuzu[ji] != ')') && (zifushuzu[ji + ] != '(') && (zifushuzu[ji - ] != '('))
                         {
                             char a;
                             a = zifushuzu[ji];
                             zifushuzu[ji] = zifushuzu[xianlinkuohao + ];
                             zifushuzu[xianlinkuohao + ] = a;
                             break;
                         }
                     }
                 }
                 if (zifushuzu[xianlinkuohao] == ')' && zifushuzu[xianlinkuohao + ] == '(')
                 {
                     for (int ji = ; ji < zifushuzulength; ji++)
                     {
                         if ((zifushuzu[ji] != '(') && (zifushuzu[ji] != ')') && (zifushuzu[ji + ] != '(') && (zifushuzu[ji - ] != '('))
                         {
                             char a;
                             a = zifushuzu[ji];
                             zifushuzu[ji] = zifushuzu[xianlinkuohao];
                             zifushuzu[xianlinkuohao] = a;
                             break;
                         }
                     }
                 }
             }

             //cout << "括号的个数为：" << kuohaogeshu<< endl;
             //cout << "运算符的个数为：" << yunsuanfugeshu<< endl;
             //cout << "字符数组的个数为：" << zifushuzulength << endl;
             //对字符数组进行输出
             /*cout << "字符数组为：";
             for (int ii = 0; ii < zifushuzulength; ii++)
             {
             cout << zifushuzu[ii] << " ";
             }
             cout << endl;
             */
             /*//对运算式进行输出
             int fuhaojishus0=0;
             if (zifushuzulength == 3)
             {
             cout << "(" << intExpressieCanYu[i][0] << yunsuanfu[0] << intExpressieCanYu[i][1] << ")";
             }
             else
             {
             for (int shuchushuzi = 0; shuchushuzi < intExpressieNumNum[i]; shuchushuzi++)
             {
             cout << intExpressieCanYu[i][shuchushuzi];
             for (; fuhaojishus0 < zifushuzulength;)
             {
             while (zifushuzu[fuhaojishus0] == ')')
             {
             cout << ")";
             fuhaojishus0 += 1;
             }
             if (fuhaojishus0 < zifushuzulength)
             {
             cout << zifushuzu[fuhaojishus0];    //输出右括号紧邻的运算符或者是输出第一个符号
             }

             fuhaojishus0 += 1;
             while (zifushuzu[fuhaojishus0] == '(')
             {
             cout << "(";
             fuhaojishus0 += 1;
             }
             break;
             }
             }
             }*/

             if ( == intPrintStyle)
             {
                 int fuhaojishus0 = ;
                 if (zifushuzulength == )
                 {
                     cout << "(" << intExpressieCanYu[i][] << yunsuanfu[] << intExpressieCanYu[i][] << ")";
                 }
                 else
                 {
                     for (int shuchushuzi = ; shuchushuzi < intExpressieNumNum[i]; shuchushuzi++)
                     {
                         cout << intExpressieCanYu[i][shuchushuzi];
                         for (; fuhaojishus0 < zifushuzulength;)
                         {
                             while (zifushuzu[fuhaojishus0] == ')')
                             {
                                 cout << ")";
                                 fuhaojishus0 += ;
                             }
                             if (fuhaojishus0 < zifushuzulength)
                             {
                                 cout << zifushuzu[fuhaojishus0];    //输出右括号紧邻的运算符或者是输出第一个符号
                             }

                             fuhaojishus0 += ;
                             while (zifushuzu[fuhaojishus0] == '(')
                             {
                                 cout << "(";
                                 fuhaojishus0 += ;
                             }
                             break;
                         }
                     }
                 }
             }
             else
             {
                 int fuhaojishus0 = ;
                 if (zifushuzulength == )
                 {
                     outfile << "(" << intExpressieCanYu[i][] << yunsuanfu[] << intExpressieCanYu[i][] << ")";
                     outfile << endl;
                 }
                 else
                 {
                     for (int shuchushuzi = ; shuchushuzi < intExpressieNumNum[i]; shuchushuzi++)
                     {
                         outfile << intExpressieCanYu[i][shuchushuzi];
                         for (; fuhaojishus0 < zifushuzulength;)
                         {
                             while (zifushuzu[fuhaojishus0] == ')')
                             {
                                 outfile << ")";
                                 fuhaojishus0 += ;
                             }
                             if (fuhaojishus0 < zifushuzulength)
                             {
                                 outfile << zifushuzu[fuhaojishus0];    //输出右括号紧邻的运算符或者是输出第一个符号
                             }

                             fuhaojishus0 += ;
                             while (zifushuzu[fuhaojishus0] == '(')
                             {
                                 outfile << "(";
                                 fuhaojishus0 += ;
                             }
                             break;
                         }
                     }
                     outfile << endl;
                 }
             }

         }

         cout << endl;
     }

     outfile.close();

     return ;

 }