c++生成算式并计算（《构建之法》第一章课后第一题）
c++实现计算器（自动生成算式并计算）
要满足的需求有以下几个：
- 自动生成随机的四则运算算式，包含括号和小数。
- 对生成的算式计算出结果。
- 算式、结果分别存储到不同的文件。
一 生成算式
由上述需求可知，算式中有运算符（'+','-','*','/','(',')'），整数，小数（重点是有小数点），同时满足程序模块化设计的要求，所以使用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;
}
