c++生成算式并计算（《构建之法》第一章课后第一题）

c++实现计算器（自动生成算式并计算）

要满足的需求有以下几个：

1. 自动生成随机的四则运算算式，包含括号和小数。
2. 对生成的算式计算出结果。
3. 算式、结果分别存储到不同的文件。

一 生成算式

由上述需求可知，算式中有运算符（'+','-','*','/','(',')'），整数，小数（重点是有小数点），同时满足程序模块化设计的要求，所以使用STL中的string类存储生成的算式。
生成算式时有几点需要注意：

• 首先生成一个数字，然后运算符（'+','-','*','/'）和数字交替出现，可以限定长度为奇数，在偶数位置（位置从0开始）生成数字，奇数位置生成运算符。
• 生成数字有整数有小数。使用一个随机变量控制生成的小数和整数的比例。
• 生成小数时控制好位数、大小。
• 生成括号时注意一个左括号一定要有一个右括号对应，因此设置一个变量存储剩余要生成的右括号的数量，即每生成一个左括号该变量加一，没生成一个右括号该变量减一。同时控制除非到了算式最后，不会出现一对括号只括住一个数字的情况。
  在程序中，以上这些由string GenerateExpression()实现，同时它还会调用int GenerateRightBracket()，int GenerateLeftBracket()，char GenerateOperator()，double GeneratNumber()，int GenerateInt()。

二 中缀表达式转为逆波兰式

逆波兰式即后缀表达式，栈可以方便的在计算机中计算后缀表达式的值。

将一个普通的中序表达式转换为逆波兰表达式的一般算法是：
首先需要分配2个栈，一个作为临时存储运算符的栈S1（含一个结束符号），一个作为输入逆波兰式的栈S2（空栈），S1栈可先放入优先级最低的运算符#，注意，中缀式应以此最低优先级的运算符结束。可指定其他字符，不一定非#不可。从中缀式的左端开始取字符，逐序进行如下步骤：

• 若取出的字符是操作数，则分析出完整的运算数，该操作数直接送入S2栈
• 若取出的字符是运算符，则将该运算符与S1栈栈顶元素比较，如果该运算符优先级(不包括括号运算符)大于S1栈栈顶运算符优先级，则将该运算符进S1栈，否则，将S1栈的栈顶运算符弹出，送入S2栈中，直至S1栈栈顶运算符低于（不包括等于）该运算符优先级，最后将该运算符送入S1栈。
• 若取出的字符是“（”，则直接送入S1栈顶。
• 若取出的字符是“）”，则将距离S1栈栈顶最近的“（”之间的运算符，逐个出栈，依次送入S2栈，此时抛弃“（”。
• 重复上面的1~4步，直至处理完所有的输入字符
• 若取出的字符是“#”，则将S1栈内所有运算符（不包括“#”），逐个出栈，依次送入S2栈。

以上来自逆波兰式-百度百科，完成以上步骤，S2栈便为逆波兰式输出结果。不过S2应做一下逆序处理。

在本程序中，使用队列（queue）取代栈S2,省去逆序处理的步骤，这些步骤由函数queue<string> ConvertToRpn(string s,map<string,int>p,map<char,int>p_char)实现。

三 计算逆波兰式

新建一个表达式,如果当前字符为变量或者为数字，则压栈，如果是运算符，则将栈顶两个元素弹出作相应运算，结果再入栈，最后当表达式扫描完后，栈里的就是结果。

计算功能由double Operation(queue<string> q)实现，同时它还会调用double Calculate(double n1, double n2, char c)。

三 存储到文件

程序运行结果包括单纯的中缀表达式和含结果的中缀表达式，分别存储到不同的文件。两文件分别如下：

完整代码

/*
    构建之法第一章习题一，实现自动生成四则运算的算式并判断用户计算的正误。
    计划分三步走：
    1.自动生成算式
    2.输入算式转换为逆波兰式
    3.计算算式结果
*/
#include<iostream>
#include<string>
#include<sstream>
#include<stack>
#include<queue>
#include<map>
#include<fstream>
using namespace std;

//将中缀表达式转换为逆波兰式
queue<string> ConvertToRpn(string s,map<string,int>p,map<char,int>p_char)
{
    int length = s.length();
    string temp_s="";
    string temp_for_push;
    stack<string>sk1;
    queue<string>sk2;
    sk1.push("#");
    for (int i = 0; i < length;)
    {
        if (isdigit(s[i]))
        {//判断字符是否是0~9的数字
            while (isdigit(s[i]) || s[i] == '.')
            {
                temp_s = temp_s + s[i];
                i++;
            }
            sk2.push(temp_s);
            temp_s.clear();
        }
        else
        {
            if (s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/'||s[i]=='^')
            {
                if (p_char[s[i]] >p[sk1.top()])
                {
                    temp_for_push.clear();
                    temp_for_push = temp_for_push + s[i];
                    sk1.push(temp_for_push);
                    i++;
                }
                else
                {
                    while (p_char[s[i]] <= p[sk1.top()])
                    {
                        sk2.push(sk1.top());
                        sk1.pop();
                    }
                    temp_for_push.clear();
                    temp_for_push = temp_for_push + s[i];
                    sk1.push(temp_for_push);
                    i++;
                }
            }
            else if (s[i] == '(')
            {
                temp_for_push.clear();
                temp_for_push = temp_for_push + s[i];
                sk1.push(temp_for_push);
                i++;
            }
            else if(s[i]==')')
            {
                while (sk1.top() != "(")
                {
                    sk2.push(sk1.top());
                    sk1.pop();
                }
                sk1.pop();
                i++;
            }
        }
        if (i == length)
        {
            while (sk1.size() != 1)
            {
                sk2.push(sk1.top());
                sk1.pop();
            }
        }
    }
    return sk2;
}

//生成随机小数
double GeneratNumber()
{
    double number;
    int temp;
    number = ((double)rand()) / ((double)(rand()/50));
    temp = number * 10;
    number = ((double)temp) / 10;
    number = number - (int)number + (int)number % 49;
    return number;
}

//生成随机整数
int GenerateInt()
{
    double int_number;
    int_number = rand() % 49;
    return int_number;
}

//计算逆波兰式中简单表达式
double Calculate(double n1, double n2, char c){
    double result = 0;
    if (c == '+'){
        result = n1 + n2;
    }
    else if (c == '-'){
        result = n2 - n1;
    }
    else if (c == '*'){
        result = n1*n2;
    }
    else if (c == '/'){
        result = n2 / n1;
    }
    return result;
}

//计算逆波兰式
double Operation(queue<string> q)
{
    stack<double> temp_for_digit;
    char temp_for_char;
    double temp_for_push = 0;
    double num1, num2;
    double temp_result = 0;
    int length = q.size();
    stringstream ss;
    while (q.size() != 0)
    {
        if (isdigit(q.front()[0]))
        {
            ss << q.front();
            ss >> temp_for_push;
            temp_for_digit.push(temp_for_push);
            q.pop();
            ss.clear();
        }
        else
        {
            temp_for_char = q.front()[0];
            q.pop();
            num1 = temp_for_digit.top();
            temp_for_digit.pop();
            num2 = temp_for_digit.top();
            temp_for_digit.pop();
            temp_result = Calculate(num1, num2, temp_for_char);
            temp_for_digit.push(temp_result);
        }
    }
    return temp_result;
}

//生成随机运算符
char GenerateOperator()
{
    char result;
    int which = rand() % 6;
    if (which == 0 || which == 4)
    {
        result = '+';
    }
    else if (which == 1 || which == 5)
    {
        result = '-';
    }
    else if (which == 2)
    {
        result = '*';
    }
    else if (which == 3)
    {
        result = '/';
    }
    return result;
}

//生成左括号
int GenerateLeftBracket()
{
    int result = 0;
    int whether_bracket = rand() % 7;
    if (whether_bracket ==1)
    {
        result = 1;
    }
    return result;
}

//生成右括号
int GenerateRightBracket()
{
    int result = 0;
    int whether_bracket = rand() % 7;
    if (whether_bracket <= 5)
    {
        result = 1;
    }
    return result;
}

//生成表达式
string GenerateExpression()
{
    string expression = "";
    string temp_string;
    int count_right_bracket = 0;
    int length = 3;
    int location_for_last_bracket = 0;
    length += 2*(rand() % 15);
    stringstream ss;
    double temp_num;
    int whether_int = 0;
    int whether_bracket = 0;
    for (int i = 0; i < length; i++)
    {
        whether_int = rand() % 5;
        if (i % 2 == 0)
        {
            if (whether_int <= 3)
            {//80%生成整数
                temp_num = GenerateInt();
            }
            else
            {
                temp_num = GeneratNumber();
            }
            ss << temp_num;
            ss >> temp_string;
            expression += temp_string;
            ss.clear();
            if (count_right_bracket&&i>=location_for_last_bracket+3)
            {
                if (GenerateRightBracket())
                {
                    count_right_bracket -= 1;
                    expression += ')';
                }
            }
        }
        else
        {
            expression += GenerateOperator();
            whether_bracket= GenerateLeftBracket();
            if (whether_bracket == 1)
            {
                expression += '(';
                count_right_bracket += whether_bracket;
                location_for_last_bracket = i;
            }
        }
    }
    while ((count_right_bracket--) != 0)
    {
        expression += ')';
    }
    return expression;
}

int main()
{
    map<string, int> priorites;
    priorites["+"] = 1;
    priorites["-"] = 1;
    priorites["*"] = 2;
    priorites["/"] = 2;
    priorites["^"] = 3;
    map<char, int> priorites_char;
    priorites_char['+'] = 1;
    priorites_char['-'] = 1;
    priorites_char['*'] = 2;
    priorites_char['/'] = 2;
    priorites_char['^'] = 3;
    string expression;
    queue<string> RPN;
    double result;
    int count_expression;
    ofstream just_expression, answer;
    just_expression.open("expression.txt");
    answer.open("answer.txt");
    cout << "how many expressions do you want: " << endl;
    cin >> count_expression;
    for (int i = 0; i<count_expression; i++)
    {
        expression = GenerateExpression();
        RPN = ConvertToRpn(expression,priorites,priorites_char);//得到后缀表达式
        result = Operation(RPN);
        just_expression << i+1 << ".  " << expression << endl;
        answer << i+1 << ".  " << expression << " = " << result << endl;
        expression.clear();
        RPN = queue<string>();//清空当前队列
    }
    just_expression.close();
    answer.close();
    cout << "finished" << endl;
    system("pause");
    return 0;
}