四则运算2—加强版

设计一个程序，实现出30道四则运算题，要支持真分数的运算
题目避免重复
可定制（数量/打印方式）
可以控制下列参数：

          是否有乘除法、
          是否有括号（最多可以支持10个数参与计算）、
          数值范围（正整数）、
          加减有无负数、
          除法有无余数

分析：

      1、使用随机数填充一个二维数组，每行数组为一个运算式中的所有用到的数字

      2、现在是整形二维数组，对每行的数值进行参数的设定（即用随机数设定），以及运算符的选择

      3、拿出第一行的数组来分析

           首先判断算式中是否应该有括号：1）没有括号     2）有括号

           分析 1)没有括号的情况

                      可以根据数组中数的数量来判断运算符的个数，再随机生成相应个数的运算符（是否有乘除法可在这一步进行设置）

                      对运算结果的限制可以分析如下：

                           首先是有无乘除法，这个比较好设置，上边以提及到。其次是分析运算过程中是否有负数出现，是否有余数出现。

                           若没有乘除法，则只需分析有无余数，若有乘除法则需根据运算规则首先分析是否有余数

                           若没有乘除法，只需分析有无负数出现即可，可顺序执行每次二元运算进行判断并处理

                           若有乘除法，则需判断参与乘除运算的数是否有余数，并进行处理。再次判断是否需要对是否有负数进行判断，若可以有负数，则直接输出即可，可不可以有负数，则对以上的结果数组再次进行分析。

                2）有括号的情况

                     存储运算数字信息的二维数组已经生成，再为每行数组生成相应的运算符数组。根据每行数组中数字的个数求得最多能够插入的括号的对数，然后据此随机生成几对括号，最后将括号的总数目加上运算符的总数目并根据一定的规则存入另外一个数组中，使得括号能够随机分配到运算式的不同位置，既可以为运算式加上括号。最后根据一定的输出方式和方法，将数字和括号，运算符以一定的顺序输出即可。

 

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

int main()
{
    int expressie_canyu[1000][10];         //这是一个二维数组，每行记录的是每个运算式中参与的数字
    int expressieNum_Num[1000];            //此数组记录二维数组相应行中的列数，及记录每个运算式中参与运算的数字的个数                 
    int number;              //定义产生的运算式中数的数量(最大为10个数)
    int expressie_num;       //定义产生的运算式的数量
    int printStyle;          //定义打印方式（DOS界面打印、输出到文件）
    int multiply_divide;     //定义是否有乘除法，0代表没有，1代表有
    int max, min;            //定义四则运算中的数的取值范围
    int minus;               //定义是否有负数，0代表没有，1代表有
    int remainder;           //定义是否有余数，0代表没有，1代表有
    int bracket;             //定义是否有括号，0代表没有，1代表有

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

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

    biaozhiwei[0] = expressie_num;
    biaozhiwei[1] = printStyle;
    biaozhiwei[2] = multiply_divide;
    biaozhiwei[3] = min;
    biaozhiwei[4] = max;
    biaozhiwei[5] = minus;
    biaozhiwei[6] = remainder;
    biaozhiwei[7] = bracket;


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

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

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

    srand((int)time(NULL));
    for (int i = 0; i < expressie_num; i++)           //对N个运算式进行循环
    {
        
        if (0 == bracket)         //如果没有括号
        {
            int yunsuanfugeshu;      //变量运算符的个数
            yunsuanfugeshu = expressieNum_Num[i] - 1;
            char yunsuanfu[10];     //此数组存储运算符
            
            for (int j = 0; j < yunsuanfugeshu; j++)     //对运算符数组进行赋值
            {
                if (0 == multiply_divide)  //如果没有乘除法
                {
                    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] = '/';
                    }
                }
            }

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

                    //下面的循环是对运算式预算过程有无负数的判断
                    for (int noMinusNum = 0; noMinusNum < (expressieNum_Num[i]-1); noMinusNum++)
                    {
                        if (yunsuanfu[noMinusNum] == '+')
                        {
                            jieguo = jieguo + expressie_canyu[i][noMinusNum + 1];
                            if (jieguo < 0)
                            {
                                int a;
                                a = jieguo - expressie_canyu[i][noMinusNum + 1];
                                expressie_canyu[i][noMinusNum + 1] = 1 + rand() % a;
                            }
                        }
                        else
                        {
                            jieguo = jieguo - expressie_canyu[i][noMinusNum + 1];
                            if (jieguo <= 0)
                            {
                                int a;
                                a = expressie_canyu[i][noMinusNum + 1] + jieguo;
                                expressie_canyu[i][noMinusNum + 1] = 1 + rand() % (a+1);
                            }
                        }
                    }

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

                            for (; fuhao < yunsuanfugeshu;)
                            {
                                cout << yunsuanfu[fuhao];
                                fuhao++;
                                break;
                            }
                        }
                    }
                    else
                    {
                        
                        int fuhao = 0;
                        for (int shu = 0; shu < expressieNum_Num[i]; shu++)
                        {
                            outfile << expressie_canyu[i][shu];

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

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

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

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

                    if (0 == minus)  //如果不能有负数
                    {
                        //下面的大循环时修改乘法或除法前面的一个运算符号为加号
                        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] == '-')
                            {
                                expressie_canyu[i][fuhaochuan + 1] = 1 + rand() % (expressie_canyu[i][fuhaochuan]);
                            }
                        }

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

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

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

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

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

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

                                for (; fuhao < yunsuanfugeshu;)
                                {
                                    outfile << yunsuanfu[fuhao];
                                    fuhao++;
                                    break;
                                }
                            }
                            outfile << endl;
                            //outfile.close();
                        }
                    }
                }
                else   //如果可以有余数
                {
                    if (0 == minus)  //如果不能有负数
                    {
                        //下面的大循环时修改乘法或除法前面的一个运算符号为加号
                        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] == '-')
                            {
                                expressie_canyu[i][fuhaochuan + 1] = 1 + rand() % (expressie_canyu[i][fuhaochuan + 1]);
                            }
                        }

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

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

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

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

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

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

                                for (; fuhao < yunsuanfugeshu;)
                                {
                                    outfile << yunsuanfu[fuhao];
                                    fuhao++;
                                    break;
                                }
                            }
                            outfile << endl;
                            //outfile.close();
                        }
                    }
                }
                
            }
        }
        else   //如果有括号
        {
            //以下各个变量为个数的定义
            int yunsuanfugeshu;      //变量运算符的个数
            yunsuanfugeshu = expressieNum_Num[i] - 1;
            char yunsuanfu[10];     //此数组存储运算符

            int zuidakuohaoshu;          //最大括号对数
            if (expressieNum_Num[i] > 2)
            {
                zuidakuohaoshu = expressieNum_Num[i] - 2;
            }
            else
            {
                zuidakuohaoshu = expressieNum_Num[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 == multiply_divide)  //如果没有乘除法
                {
                    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 << "(" << expressie_canyu[i][0] << yunsuanfu[0] << expressie_canyu[i][1] << ")";
            }
            else
            {
                for (int shuchushuzi = 0; shuchushuzi < expressieNum_Num[i]; shuchushuzi++)
                {
                    cout << expressie_canyu[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 == printStyle)
            {
                int fuhaojishus0 = 0;
                if (zifushuzulength == 3)
                {
                    cout << "(" << expressie_canyu[i][0] << yunsuanfu[0] << expressie_canyu[i][1] << ")";
                }
                else
                {
                    for (int shuchushuzi = 0; shuchushuzi < expressieNum_Num[i]; shuchushuzi++)
                    {
                        cout << expressie_canyu[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 << "(" << expressie_canyu[i][0] << yunsuanfu[0] << expressie_canyu[i][1] << ")";
                    outfile << endl;
                }
                else
                {
                    for (int shuchushuzi = 0; shuchushuzi < expressieNum_Num[i]; shuchushuzi++)
                    {
                        outfile << expressie_canyu[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;
    
}

实验截图：

项目计划总结：

日期任务	听课/时	编写程序/时	查阅资料/时	日总计/时
星期一	2	1.5	0.5	4
星期二		2		2
星期三		3	1	4
星期四	2	2		4
星期五		2.5	1	3.5
星期六		5	2	7
星期日
周总计	4	15.5	4.5	24.5

时间记录日志：

日期	开始时间	结束时间	中断时间	净时间	活动	备注
3/7	14：00	15：50	10	100	上课	软件工程
	16：30	18：00		60	编写程序	四则运算作业
	21:30	22：00		30	阅读书籍	《构建之法》
3/8	19：00	21：00	20	90	编写程序，查阅资料	四则运算作业
3/9	14:25	16:30	15	110	编写程序	四则运算作业
	17:00	18:00		60	查阅资料和阅读《构建之法》
	21:00	22：:00		60	编写程序	四则运算作业
3/10	14：00	15：50	10	100	上课	软件工程上课
	21:20	22：10		50	查阅资料，编写程序	四则运算作业
3/11	16：20	18：30	10	120	编写程序
	19：40	20:30		50	阅读《构建之法》
	21:00	21：45		45	查阅资料	上网查阅资料
3/12	9：00	11:40		160	编程	作业
	12:20	15:00		160	调试程序
	17:00				写博客

缺陷记录日志：

日期	编号	引入阶段	排除阶段	修复时间&问题描述
3/7	1	编码	编译	花费半小时，负数问题得不到控制。
3/8
3/9
3/10	2	编码	编译	花费1.5小时，运算式输出有多余项，循环不正确。
3/11	3	编码	编译	花费半小时，调试过程出错，除数不能为零