接着上一篇博客（点击打开链接）中关于栈在中缀表达式和后缀表达式中的应用，这次分享下自己的一个简单的计算器实现的代码。
那就暴力简单些，直接上代码：
类定义的代码如下：
#ifndef CALCULATOR_H
#define CALCULATOR_H
#include<string>
#include<vector>
using namespace std;
class Calculator
{
public:
Calculator(int num = 0)
{
init(num);
}
bool isValid(const string &expression) const;
double calculate(const string &expression) const; //主要是对后缀表达式求解结果
double arithmeticSign(char sign, double num1, double num2) const; //用于计算两个数之间的结果
friend double string_to_digit(const string &str); //将字符串转化为数字
private:
int m_num;
vector<char> m_standard;
void init(int num);
bool isStandard(const string &expression) const;
bool isSign(char ch) const; //判断一个字符是否是运算符
bool ComparePriority(char sign1, char sign2)const; //比较两个运算符的优先级
void infixToSuffix(const string &expression, vector<double> &num_vec, vector<char> &cmp_vec, vector<bool> &loc_vec)const; //将一个中缀表达式转化为后缀表达式
};
#endif
类的具体实现如下：
#include<stack>
#include<iostream>
#include<map>
#include"Calculator.h"
using namespace std;
void Calculator::init(int num)
{
char str[18] = { '0','1','2','3','4','5','6','7','8','9','.','(',')','+','-','*','/' };
m_num = num;
for (int i = 0; str[i] != ' '; i++)
m_standard.push_back(str[i]);
}
bool Calculator::isStandard(const string &expression) const
{
for (int i = 0; i<expression.size(); i++)
{
if (find(m_standard.begin(), m_standard.end(), expression[i]) == m_standard.end())
return false;
}
return true;
}
bool Calculator::isSign(char ch) const
{
if (find(m_standard.begin() + 11, m_standard.end(), ch) == m_standard.end())
return false;
return true;
}
void Calculator::infixToSuffix(const string &expression, vector<double> &num_vec, vector<char> &cmp_vec, vector<bool> &loc_vec)const
{
if (!isStandard(expression))
{
cerr << "**********输入有误**********" << endl;
exit(EXIT_FAILURE);
}
if (!isValid(expression))
{
cerr << "**********输入有误**********" << endl;
exit(EXIT_FAILURE);
}
int first = 0;
stack<char> stackChar;
for (int i = 0; i<expression.size(); i++)
{
if (isSign(expression[i]) || (i == expression.size() - 1))
{
string substr(expression.begin() + first, expression.begin() + i);
if (i == expression.size() - 1 && !isSign(expression[i])) //当i代表最后一个字符且不是运算符的时候，那么这个数字得合并向前一个数字中
substr += expression[i];
if (!substr.empty()) //此时处理的是数字
{
double num = string_to_digit(substr);
//将数字放入数字向量，并记录相应的位置属性
num_vec.push_back(num);
loc_vec.push_back(false);
}
if(isSign(expression[i])) //处理字符的时候
{
if (expression[i] == ')')
{
while (!stackChar.empty())
{
char cmp = stackChar.top();
stackChar.pop();
if (cmp == '(')
break;
//将运算符放入字符向量中，并用位置向量记录位置属性
cmp_vec.push_back(cmp);
loc_vec.push_back(true);
}
}
else
{
if (!stackChar.empty())
{
char ch = stackChar.top();
if (ch=='('||!ComparePriority(ch, expression[i]))
{
stackChar.push(expression[i]);
}
else
{
cmp_vec.push_back(ch);
stackChar.pop();
loc_vec.push_back(true);
}
}
else {
stackChar.push(expression[i]);
}
}
}
first = i + 1;
}
}
while (!stackChar.empty())
{
cmp_vec.push_back(stackChar.top());
stackChar.pop();
loc_vec.push_back(true);
}
}
bool Calculator::isValid(const string &expression) const
{
if (isStandard(expression) == false)
return false;
stack<char> stk;
for (int i = 0; i<expression.size(); i++)
{
if (expression[i] == '(' || expression[i] == '[')
stk.push(expression[i]);
else if (expression[i] == ')')
{
if (stk.top() != '(')
return false;
else
stk.pop();
}
else if (expression[i] == ']')
{
if (stk.top() != '[')
return false;
else
stk.pop();
}
}
if (stk.empty())
return true;
else
return false;
}
double Calculator::calculate(const string &expression) const
{
vector<double> num_vec;
vector<char> cmp_vec;
vector<bool> loc_vec;
stack<double> stackDouble;
stack<char> stackChar;
int index_num = 0, index_cmp = 0;
//将中缀表达式转化为后缀表达式
infixToSuffix(expression, num_vec, cmp_vec, loc_vec);
for (int i = 0; i < loc_vec.size(); i++)
{
if (!loc_vec[i]) //当i位置处是数字的时候
{
stackDouble.push(num_vec[index_num++]);
}
else
{
if (stackDouble.size() < 2)
{
cerr << "对不起，输入的表达式有误，无法计算" << endl;
exit(EXIT_FAILURE);
}
double num1 = stackDouble.top();
stackDouble.pop();
double num2 = stackDouble.top();
stackDouble.pop();
stackDouble.push(arithmeticSign(cmp_vec[index_cmp++], num2, num1));
}
}
if (stackDouble.size() != 1 || !stackChar.empty())
{
cerr << "对不起，输入的表达式有误，无法计算" << endl;
exit(EXIT_FAILURE);
}
return stackDouble.top();
}
double string_to_digit(const string &str)
{
double digit = 0;
auto it = find(str.begin(), str.end(), '.');
if (it == str.end())
{
int n = 1;
for (int i = str.size() - 1; i >= 0; i--)
{
digit += (str[i] - '0')*n;
n *= 10;
}
}
else
{
int n = 1;
int location = it - str.begin();
for (int i = location - 1; i >= 0; i--)
{
digit += (str[i] - '0')*n;
n *= 10;
}
double m = 0.1;
for (int i = location + 1; i<str.size(); i++)
{
digit += (str[i] - '0')*m;
m *= 0.1;
}
}
return digit;
}
double Calculator::arithmeticSign(char sign, double num1, double num2) const
{
if (sign == '+')
return num1 + num2;
else if (sign == '-')
return num1 - num2;
else if (sign == '*')
return num1*num2;
else if (sign == '/')
{
if (num2 == 0)
{
cerr << "********除数不能为0*******" << endl;
exit(EXIT_FAILURE);
}
return num1 / num2;
}
}
bool Calculator::ComparePriority(char sign1, char sign2)const //用于比较第一个符号的优先级是否比第二个大
{
map<char, int> SignGather;
SignGather.insert(pair<char, int>('(', 1));
SignGather.insert(pair<char, int>('*', 2));
SignGather.insert(pair<char, int>('/', 2));
SignGather.insert(pair<char, int>('+', 3));
SignGather.insert(pair<char, int>('-', 3));
if (SignGather[sign1]<SignGather[sign2])
return true;
else
return false;
}
测试的main函数如下：
#include<iostream>
#include"Calculator.h"
using namespace std;
int main()
{
Calculator calculator;
string str;
cout << "请输入一个数学表达式（其中要求符号是英文，且无空白符）：" << endl;
cin >> str;
double result = calculator.calculate(str);
cout << result << endl;
return 0;
}
下面主要说一下这个代码的思路：
（1）首先我们主要是构造一个计算器的类Calculator，用于处理我们的计算表达式。
（2）对于输入的数学表达式，我们用string进行存放，但是并不会将它作为类的成员变量，因为我们都知道，对于一个计算器而言，没有必要存储这种变量，因为用户会一直输入不同的表达式，所以存储它是没有什么太大的作用的，所以我们这里就不存储它了。
（3）对于输入的表达式，我们有专门的函数isValid和isStandard对其进行初步的简单检测，以判定是否符合标准。当然对于这个标准而言，我们所定义的标准是存放在成员变量m_standard中的，在这个向量中，我们定义了数学表达式中允许出现的合法的字符。
（4）之后，就是需要对表达式进行解析了，因为我们是将表达式当做一个string读入的，所以如何判定数字和运算符需要我们自己处理。这里我们定义了一个函数几个函数进行这方面的处理，其中string_to_digit函数会将制定的字符串转化为数字，isSign函数会判断一个字符是否为元素符。在这里我们需要着重注意一下如何拆分表达式，在程序中，对于表达式的处理，我是这样做的：我会从下标0开始逐个读取string表达式中的字符，定义一个first用于标记读的起始位置，当读到运算符的时候我会停下来，因为在数学表达式中，运算符之间的就是操作数了（当然对于“（”、“）”与其它操作符相邻的情况也可以处理的），这个时候，在first和运算符之间的这部分子串就试数字，这个时候我们可以使用函数将数字解析出来，同时也就解析出来运算符。
（5）对于解析出来的数字和运算符，我们首先需要将它们处理成后缀表达式，这才是我们的主要目的。那么问题来了，这个后缀表达式该如何进行存放呢？继续存放成一个string？这显然不是我们愿意看见的，因为我们好不容易将string解析出来了，这个时候又把它转化回去，想想都不开心。有什么办法可以同时记录下数字和字符的后缀表达式呢？这里呢，我们用三个向量进行存放，分别为num_vec，cmp_vec和loc_vec，分别用于存放数字、运算符和位置参数。在处理string表达式过程中，当解析出一个数字的时候，我们就将它放入num_vec中，并将一个false放入loc_vec中；当解析出一个运算符的时候，我们就将它放入cmp_vec中，并将一个true放入loc_vec中，直至处理完毕。在这里main，loc_vec是很重要的，我们将用它记录数字和运算符的位置，用false表示此处的东西在num_vec中，用true表示此处的东西在cmp_vec中，大家仔细体会下这个处理方法，并结合代码看下。
（6）在步骤（5）中，我们可以得到一个后缀表达式了，之后便可以根据得到的num_vec，cmp_vec和loc_vec对后缀表达式进行读取和处理，这部分的处理就比较简单了，大家可以看下代码。
至此，我们的这个简单的计算器就可以使用了，当然啦这是一个命令行的计算器，比较粗糙，后面将会更新一个图形化界面的计算器。当然，这个代码没有经过很多的测试，可能存在不足，如果有错误请大家留言，我会做出相应的修改，这次就分享到这了。