四则运算之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[1000][10];         //这是一个二维数组，每行记录的是每个运算式中参与的数字
    int intExpressieNumNum[1000];            //此数组记录二维数组相应行中的列数，及记录每个运算式中参与运算的数字的个数                 
    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[9];       //标志位，记录各个条件

    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[0] = intExpressieNum;
    intBiaozhiwei[1] = intPrintStyle;
    intBiaozhiwei[2] = intMultiplyDivide;
    intBiaozhiwei[3] = min;
    intBiaozhiwei[4] = intMax;
    intBiaozhiwei[5] = intMinus;
    intBiaozhiwei[6] = intRemainder;
    intBiaozhiwei[7] = intBracket;


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

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

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

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

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

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

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

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

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

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

                            }
                        }
                    }

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

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

                        int fuhao = 0;
                        for (int shu = 0; 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 (0 == intPrintStyle)
                    {
                        int fuhao = 0;
                        for (int shu = 0; shu < intExpressieNumNum[i]; shu++)
                        {
                            cout << intExpressieCanYu[i][shu];

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

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

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

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

                                        break;
                                    }
                                }
                            }
                        }
                        //以上为修改乘法和除法符号前边的符号+
                        //以下为判断正负
                        for (int fuhaochuan = 0; fuhaochuan < yunsuanfugeshu; fuhaochuan++)
                        {
                            if (yunsuanfu[fuhaochuan] == '-')
                            {
                                intExpressieCanYu[i][fuhaochuan + 1] = 1 + 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 = 0; qi < intExpressieNumNum[i]; qi++)
                        {
                            if (intExpressieCanYu[i][qi] < 0)
                            {
                                intExpressieCanYu[i][qi] = 1;
                            }
                        }
                        if (0 == intPrintStyle)
                        {
                            int fuhao = 0;
                            for (int shu = 0; shu < intExpressieNumNum[i]; shu++)
                            {
                                cout << intExpressieCanYu[i][shu];

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

                            int fuhao = 0;
                            for (int shu = 0; 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 (0 == intPrintStyle)
                        {
                            int fuhao = 0;
                            for (int shu = 0; shu < intExpressieNumNum[i]; shu++)
                            {
                                cout << intExpressieCanYu[i][shu];

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

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

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

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

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

                            int fuhao = 0;
                            for (int shu = 0; 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 (0 == intPrintStyle)
                        {
                            int fuhao = 0;
                            for (int shu = 0; shu < intExpressieNumNum[i]; shu++)
                            {
                                cout << intExpressieCanYu[i][shu];

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

                            int fuhao = 0;
                            for (int shu = 0; 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] - 1;
            char yunsuanfu[10];     //此数组存储运算符

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

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

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

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

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

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

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


            }

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

            //校正字符数组，使得其中不能有相邻的括号
            //下面是校正左括号
            for (int xianlinkuohao = 0; xianlinkuohao < (zifushuzulength - 1); xianlinkuohao++)
            {
                if (zifushuzu[xianlinkuohao] == '(' && zifushuzu[xianlinkuohao + 1] == ')')
                {
                    for (int ji = 1; ji < zifushuzulength; ji++)
                    {
                        if ((zifushuzu[ji] != '(') && (zifushuzu[ji] != ')') && (zifushuzu[ji + 1] != ')') && (zifushuzu[ji - 1] != ')'))
                        {
                            char a;
                            a = zifushuzu[ji];
                            zifushuzu[ji] = zifushuzu[xianlinkuohao];
                            zifushuzu[xianlinkuohao] = a;
                            break;
                        }
                    }
                }
                if (zifushuzu[xianlinkuohao] == ')' && zifushuzu[xianlinkuohao + 1] == '(')
                {
                    for (int ji = 1; ji < zifushuzulength; ji++)
                    {
                        if ((zifushuzu[ji] != '(') && (zifushuzu[ji] != ')') && (zifushuzu[ji + 1] != ')') && (zifushuzu[ji - 1] != ')'))
                        {
                            char a;
                            a = zifushuzu[ji];
                            zifushuzu[ji] = zifushuzu[xianlinkuohao + 1];
                            zifushuzu[xianlinkuohao + 1] = a;
                            break;
                        }
                    }
                }
            }
            //下面是校正右括号
            for (int xianlinkuohao = 0; xianlinkuohao < (zifushuzulength - 1); xianlinkuohao++)
            {
                if (zifushuzu[xianlinkuohao] == '(' && zifushuzu[xianlinkuohao + 1] == ')')
                {
                    for (int ji = 1; ji < zifushuzulength; ji++)
                    {
                        if ((zifushuzu[ji] != '(') && (zifushuzu[ji] != ')') && (zifushuzu[ji + 1] != '(') && (zifushuzu[ji - 1] != '('))
                        {
                            char a;
                            a = zifushuzu[ji];
                            zifushuzu[ji] = zifushuzu[xianlinkuohao + 1];
                            zifushuzu[xianlinkuohao + 1] = a;
                            break;
                        }
                    }
                }
                if (zifushuzu[xianlinkuohao] == ')' && zifushuzu[xianlinkuohao + 1] == '(')
                {
                    for (int ji = 1; ji < zifushuzulength; ji++)
                    {
                        if ((zifushuzu[ji] != '(') && (zifushuzu[ji] != ')') && (zifushuzu[ji + 1] != '(') && (zifushuzu[ji - 1] != '('))
                        {
                            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 (0 == intPrintStyle)
            {
                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;
                        }
                    }
                }
            }
            else
            {
                int fuhaojishus0 = 0;
                if (zifushuzulength == 3)
                {
                    outfile << "(" << intExpressieCanYu[i][0] << yunsuanfu[0] << intExpressieCanYu[i][1] << ")";
                    outfile << endl;
                }
                else
                {
                    for (int shuchushuzi = 0; shuchushuzi < intExpressieNumNum[i]; shuchushuzi++)
                    {
                        outfile << intExpressieCanYu[i][shuchushuzi];
                        for (; fuhaojishus0 < zifushuzulength;)
                        {
                            while (zifushuzu[fuhaojishus0] == ')')
                            {
                                outfile << ")";
                                fuhaojishus0 += 1;
                            }
                            if (fuhaojishus0 < zifushuzulength)
                            {
                                outfile << zifushuzu[fuhaojishus0];    //输出右括号紧邻的运算符或者是输出第一个符号
                            }

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

        }

        cout << endl;
    }

    outfile.close();

    return 0;

}