控制台下的计算器——C++实现

最新推荐文章于 2021-08-23 10:53:45 发布
最新推荐文章于 2021-08-23 10:53:45 发布
阅读量2k 收藏 9
点赞数 2
分类专栏： c/c++杂七杂八
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fang92/article/details/47154725
版权

最近这段时间看操作系统的东西看的头晕脑胀的，所以先停个一晚上，写个控制台下的计算器，来练练栈的使用。

首先，分析一下要完成的东西。输入肯定使用string类来输入的，然后第一步，就是把string的字符串转化成数字存储起来。转化的这个数字存储是中序表达式，由于运算符有优先级的问题，中序表达式直接计算结果不好计算，所以需要把他转化成后序表达式，最后进行计算。

主要的函数：

(1)把string转化为中序表达式，用vector<double>的类型存储。

(2)把中序表达式转化为后序表达式。

(3)从后序表达式里面，进行计算，得到计算的结果。

程序部分：

一：先写个提示信息和表达式的输入函数，这个部分比较容易

void promptInfo()
{
	cout << "please write a expression which is only includes the +-*/ and ()" << endl;
	cout << "if you want to exit, please input the \"end\" or entry key " << endl;
}

void getExpression(string& expresion)
{
	getline(cin, expresion);
	//在表达式后面多加一个空格，有利于下面的转化中序表达式
	expresion = expresion + " ";
}

这两个函数里面，在得到了输入的表达式后，人为的给表达式加了一个空格：

expresion = expresion + " ";

这个主要考虑到后面把输入的string表达式转化为中序表达式的步骤。后面会再说。其他部分没有什么，都是比较简单的输入输出。


二：string转化为中序表达式

在这个部分，要把string转化double型的数据。主要有以下几个难点：

1.表达式里面的符号的存储方法.

2.表达式中的数字有小数，要考虑到这点。


2.1 表达式符号的存储

表达式里面，如果假设表达式是正确输入的话，那里面除了数字，就全部都是符号了，总共有：+-*/（） .7种类型。数字是0—9，那也就是说，在表达式里面，是不可能出现负数的(-3会被解析为一个“-”和数字3).所以初步想法就是把表达式里面的符号用负数来存储。+-*/（）. 这7个符号分别对应-1—-7。为了增加可读性，用宏定义的方法来表示7中特殊的符号

#define ADD 		-1
#define MINUS 		-2
#define MUL 		-3
#define DIVIDE		-4
#define L_BRACKET 	-5
#define R_BRACKET	-6
#define DOT		-7



2.2表达式里面的小数

表达式里面的小数，使用一个标示变量dotFlag。如果在表达式的遍历过程中，出现了.小数点这个符号，则dotFlag+1，并且对他后面的字符串遍历过程中，在遇到特殊符号或者空格之前，不断的增加dotFlag的大小，标示小数的位数，在最后把整个数字存入结果的时候，调用pow(10,dotFlag)来作为除数，得到相应的小数。也就是首先把在字符串里面出现的所有的数字当成是整数，如果出现小数点，用dotFlag来记录小数的位数，最后用得到的字符串的整数来/pow(10,dotFlag),来得到相应的小数。

2.3

整个转化函数如下：

vector<double>  strToDouble(const string& expression)
{
	vector<double> ret;
	int dotFlag = -1;	//dotFlag表示小数位数
	double num = -1;
	int strSize = expression.size();
	const char* str = expression.c_str();
	for (int i = 0; i<strSize; ++i)
	{
		int temp = table(str[i]);
		if (temp == 10){
			if (num != -1){
				if (dotFlag == -1)	//如果没有出现小数点，则需要加上1
					dotFlag++;
				num = num / pow(10, dotFlag);
				ret.push_back(num);
			}

			dotFlag = -1;
			num = -1;
			continue;
		}
		if (temp >= 0 && temp<=9 )	{
			if (num == -1)
				num = 0;
			num = num * 10 + temp;
			if (dotFlag >= 0)
				dotFlag++;
			continue;
		}

		if (temp == DOT)	{
			dotFlag++;
			continue;
		}
		
		if (num != -1)
		{
			if (dotFlag == -1)
				dotFlag++;
			num = num / pow(10, dotFlag);
			ret.push_back(num);
		}
		ret.push_back(temp);
		num = -1;
		dotFlag = -1;
	}
	
	return ret;
}



整个转化函数的思路比较简单，从头开始遍历真个字符串，如果得到的char变量是数字，则使用下面的算式来得到数字，其中dotflag是小数点位数的标示变量，当遇到小数点时，dotflag就会由-1变为0，然后记录小数点后面的数字位数，在最后处理数字： 

if (temp >= 0)	{
			if (num == -1)
				num = 0;
			num = num * 10 + temp;
			if (dotFlag >= 0)
				dotFlag++;
			continue;
		}

如果得到的是除了小数点以外的符号，则把前面得到的num经过处理，存储起来：

	if (num != -1){
		if (dotFlag == -1)	//如果没有出现小数点，则需要加上1
			dotFlag++;
		num = num / pow(10, dotFlag);
		ret.push_back(num);
	}

	dotFlag = -1;
	num = -1;

这里要注意num的值和dotFlag的值都用-1来初始化而不用零。主要是因为当num用0来初始化的时候，当num的值是0，程序无法判断是因为字符串里面的数字是0还是num是初始化的值，就无法决定要不要存储num的值。

而dotFlag初始化为-1，是因为当字符串遇到小数点时，dotflag需要加一，以后再遇到特殊符号之前每遇到一位数字，dotflag都会+1，仔细算一下就会发现，dotflag的值比真实的小数点的位数多了1，所以有两个办法，一个就是再最后把dotflag-1， 或者dotflag再初始化时就设为-1.

这里还需要解答上面一个问题，再最开始的时候，输入的表达式人为的加了一个空格符号在末尾：

expresion = expresion + " ";

这个主要考虑到，在进行strToDouble()函数时，我是在遇到一个特殊符号时，来判断是否需要把num存入中序表达式，而在字符串表达式的末尾，不一定会有特殊符号，如果最后一位是以数字结尾的，则最后的数字会丢失。所以要对这种情况加以讨论。如果针对这种特殊的情况进行讨论，则会显得比较麻烦，所以想到，在得到的string表达式的最后一位，人为的加上一个空格，保证不会丢失数字，这样的方法比前面的特殊针对，在加代码要方便的多，而且效果应该更好。


三：中序表达式转后序表达式

这个主要依据以下算法来进行转化：

1.如果数据是数字，则直接存入后序表达式的存储队列。

2.如果是符号：

2.1 若是* / （, 则存入栈

2.2 若是 +，-， 如果栈为空，则直接存入栈内。否则查看栈顶元素，如果栈顶元素是(，则直接存入栈；否则，比较栈顶元素和存入元素的优先级，如果栈顶元素优先级较高(如* /)，则压出栈顶元素，存入后序表达式队列，继续比较新的栈顶元素，直到两者的优先级相同或者栈顶元素的优先级小于要压入的元素。

2.3如果是右括号，则查看栈顶元素，如果栈顶元素不是左括号，则压出元素，存入后序表达式，直到遇到左括号，丢弃左括号和右括号。

3.当中序表达式遍历完成，压出栈内所有元素，按照出栈顺序来存入后序表达式。


举例：2+3*（4+5）转化为后序表达式就是：2 3 4 5 + * +

代码如下：

vector<double> midToPost(const vector<double>& midOrder)
{
	vector<double> postOrder;
	stack<double> op;
	int length = midOrder.size();
	for (int i = 0; i < length; ++i)
	{
		double temp = midOrder[i];
		// 数字直接入列
		if (temp >= 0){
			postOrder.push_back(midOrder[i]);
			continue;
		}
		//符号分情况讨论
		else{
			//( * / 三种符号直接入列
			if (temp == L_BRACKET || temp == MUL || temp == DIVIDE){
				op.push(temp);
				continue;
			}
			//+ - 分情况讨论，查看栈顶符号的优先级
			if (temp == ADD || temp == MINUS){
				if (op.empty() || op.top() == ADD || op.top() == MINUS || op.top() == L_BRACKET){
					op.push(temp);
					continue;
				}
				else{
						int stackOp = op.top();
						postOrder.push_back(stackOp);
						op.pop();
						i--;	//反复查询
						continue;
				}	
			}

			if (temp == R_BRACKET){
				int stackOp = op.top();
				op.pop();
				if (stackOp != L_BRACKET){
					postOrder.push_back(stackOp);
					i--;	//反复查询
				}

			}

		}
	}
	while (!op.empty()){
		postOrder.push_back(op.top());
		op.pop();
	}
	return postOrder;
}

四：通过后序表达式计算结果

有了后序表达式，来计算结果就比较简单了，过程就是遍历后序表达式，如果是数字，则压入栈内，如果是符号，则把连续压出栈内的两个数字，按顺序进行相关的计算，然后把结果压入栈内。最后栈内的数字就是计算的结果

代码如下：

double calculate(const vector<double>& postOrder)
{
	stack<double> num;
	auto length = postOrder.size();
	for (int i = 0; i < length; i++){
		double temp = postOrder[i];
		if (temp >= 0){
			num.push(temp);
			continue;
		}
		else{
			double postNum = num.top();
			num.pop();
			double preNum = num.top();
			num.pop();
			double result;
			switch ((int)temp){
			case ADD: result = preNum + postNum; break;
			case MINUS: result = preNum - postNum; break;
			case MUL: result = preNum * postNum; break;
			case DIVIDE: result = preNum / postNum; break;
			}
			num.push(result);
			continue;
		}
	}
	return num.top();
}


总结：

这个计算器的程序，感觉最麻烦的部分还是在字符串转化为中序表达式，其他的两个部分就是栈的一个简单的应用，中序表达式转为后序表达式只要知道相关的算法，还是蛮容易的。后面的后序表达式计算结果，也比较简单。

这个控制台的计算器，还是很简陋的，最大的问题，就是要求输入的算是必须是正确的，比如，你不能输((3+5)这样的算式，在程序里面，无法检测出来，这是一个最大的问题。如果要改，还需要加入相应的代码，但其实都差不多，这里就不在加了。

后期如果相加上其他更多的操作其实也行，比如加上2^3这样的操作符，只要在相应的代码部分添加就可以。

最后，本来编写这个程序实在Ubuntu的sublime text 3下编的。可能自己太low，总感觉很不舒服，最后还是回到windows下用VS编了，到现在为止，还是感觉vs用起来最爽。


附上完整程序的代码：

#include<iostream>
#include<string>
#include<cmath>
#include<stack>
#include<vector>

using namespace std;

#define ADD 		-1
#define MINUS 		-2
#define MUL 		-3
#define DIVIDE		-4
#define L_BRACKET 	-5
#define R_BRACKET	-6
#define DOT		-7



void promptInfo();<span style="white-space:pre">	</span>//提示信息
void getExpression(string& expresion);<span style="white-space:pre">	</span>//得到表达式
vector<double>  strToDouble(const string& expression);<span style="white-space:pre">	</span>//字符串表达式转化为数字型的中序表达式
int table(char c);
vector<double> midToPost(const vector<double>& midOrder);//中序表达式转化为后序表达式
double calculate(const vector<double>& postOrder);<span style="white-space:pre">		</span>//通过后序表达式得到计算结果

int main()
{
	while (1)
	{
		string expression;
		promptInfo();
		getExpression(expression);
		if (expression == "end " || expression == " ")
			break;
		vector<double> midOrder = strToDouble(expression);
		vector<double> postOrder = midToPost(midOrder);
		double result = calculate(postOrder);
		cout << expression << "= " << result << endl;
	

	}
	return 0;
}

void promptInfo()
{
	cout << "please write a expression which is only includes the +-*/ and ()" << endl;
	cout << "if you want to exit, please input the \"end\" or entry key " << endl;
}

void getExpression(string& expresion)
{
	getline(cin, expresion);
	//getline不会输入最后的换行符，所以加一个字符进去，防止最后一个数字被忽略
	expresion = expresion + " ";
}

vector<double>  strToDouble(const string& expression)
{
	vector<double> ret;
	int dotFlag = -1;	//dotFlag表示小数位数
	double num = -1;
	int strSize = expression.size();
	const char* str = expression.c_str();
	for (int i = 0; i<strSize; ++i)
	{
		int temp = table(str[i]);
		if (temp == 10){
			if (num != -1){
				if (dotFlag == -1)	//如果没有出现小数点，则需要加上1
					dotFlag++;
				num = num / pow(10, dotFlag);
				ret.push_back(num);
			}

			dotFlag = -1;
			num = -1;
			continue;
		}
		if (temp >= 0 && temp<=9 )	{
			if (num == -1)
				num = 0;
			num = num * 10 + temp;
			if (dotFlag >= 0)
				dotFlag++;
			continue;
		}

		if (temp == DOT)	{
			dotFlag++;
			continue;
		}
		
		if (num != -1)
		{
			if (dotFlag == -1)
				dotFlag++;
			num = num / pow(10, dotFlag);
			ret.push_back(num);
		}
		ret.push_back(temp);
		num = -1;
		dotFlag = -1;
	}
	
	return ret;
}

int table(char c)
{
	switch(c){
    case '0': return 0; 		break;
	case '1': return 1; 		break;
	case '2': return 2; 		break;
	case '3': return 3; 		break;
	case '4': return 4; 		break;
	case '5': return 5; 		break;
	case '6': return 6; 		break;
	case '7': return 7; 		break;
	case '8': return 8; 		break;
	case '9': return 9; 		break;
	case '+': return ADD; 		break;
	case '-': return MINUS; 	break;
	case '*': return MUL; 	break;
	case '/': return DIVIDE; 	break;
	case '(': return L_BRACKET; 	break;
	case ')': return R_BRACKET; 	break;
	case '.': return DOT; 		break;
	default: return 10;	//其他情况或者空格
	}

}

vector<double> midToPost(const vector<double>& midOrder)
{
	vector<double> postOrder;
	stack<double> op;
	int length = midOrder.size();
	for (int i = 0; i < length; ++i)
	{
		double temp = midOrder[i];
		// 数字直接入列
		if (temp >= 0){
			postOrder.push_back(midOrder[i]);
			continue;
		}
		//符号分情况讨论
		else{
			//( * / 三种符号直接入列
			if (temp == L_BRACKET || temp == MUL || temp == DIVIDE){
				op.push(temp);
				continue;
			}
			//+ - 分情况讨论，查看栈顶符号的优先级
			if (temp == ADD || temp == MINUS){
				if (op.empty() || op.top() == ADD || op.top() == MINUS || op.top() == L_BRACKET){
					op.push(temp);
					continue;
				}
				else{
						int stackOp = op.top();
						postOrder.push_back(stackOp);
						op.pop();
						i--;	//反复查询
						continue;
				}	
			}

			if (temp == R_BRACKET){
				int stackOp = op.top();
				op.pop();
				if (stackOp != L_BRACKET){
					postOrder.push_back(stackOp);
					i--;	//反复查询
				}

			}

		}
	}
	while (!op.empty()){
		postOrder.push_back(op.top());
		op.pop();
	}
	return postOrder;
}

double calculate(const vector<double>& postOrder)
{
	stack<double> num;
	auto length = postOrder.size();
	for (int i = 0; i < length; i++){
		double temp = postOrder[i];
		if (temp >= 0){
			num.push(temp);
			continue;
		}
		else{
			double postNum = num.top();
			num.pop();
			double preNum = num.top();
			num.pop();
			double result;
			switch ((int)temp){
			case ADD: result = preNum + postNum; break;
			case MINUS: result = preNum - postNum; break;
			case MUL: result = preNum * postNum; break;
			case DIVIDE: result = preNum / postNum; break;
			}
			num.push(result);
			continue;
		}
	}
	return num.top();
}




fang92
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
输入两个数字和运算符，计算两个数字之间的运算
sadfdssdfs的博客
01-05 6683
让用户在控制台录入两个数，并输入运算符 计算2个数字 static void Main() {Console.WriteLine("请输入第一个数字"); String num01 = Console.ReadLine(); Console.WriteLine("请输入第二个数字"); String num0...
控制台计算器
qq_43687386的博客
01-21 202
public static void main(String[] args) { judge(); } //加法的浮点数重载 public static void add(){ Scanner scanner = new Scanner(System.in); double add1 =0; double add2 =0; System.out.println("请输入数字"); .
VECTOR基础用法--C++
爱吃芒果的薯条 的博客
02-08 1269
VECTOR一、什么是Vector？二、函数实现1、定义和初始化2、增加函数3、删除函数4、遍历函数5、判断函数6、函数值大小7、其他函数三、基本用法四、建议使用场景 第一次写CSDN博客，简单记录一下C++中的Vector用法。 一、什么是Vector？ 向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其他类型容器一样，它能够存放各种类型的对...
关于Windows计算机的一些常用的查看命令，不间断更新中......
PATH_HOME的博客
08-23 6187
进入某一个目录 ：cd 目录名/ 标准写法 你可以用cd 目录xxx 直接tab查看目录内的内容：dir （类似于linux系统中ls或者ll）进入某一个盘 : 输入 “d:” （输入双引号内的内容）创建一个空文件：输入“type null>123.txt” （含义：null为空 type类型为后缀是.txt文件）往文件内输入内容：输入 echo xxx>123.txt （echo打印 将内容输入进123.txt）根据小伙伴的建议：如何对文件 | 目录的删除详细操作删除文件：del。
C++版控制台计算器
ProgramChangesWorld的专栏
10-31 1535
本例是用C++写的一个简单计算器，输入计算表达式，然后就可以
C++MFC计算器
03-19
首先，我们关注的是计算器的基本功能——加减乘除运算。在C++中，这些基本运算可以通过操作符重载来实现，为自定义类型赋予数学运算的能力。例如，可以创建一个名为`Operand`的类，重载`+`，`-`，`*`和`/`操作符，以...
jisuanqi.zip_简单计算器
最新发布
09-21
这个软件能够实现基本的四则运算——加、减、乘、除，适用于初学者熟悉QT编程环境和GUI（图形用户界面）开发。 【描述】中的“简单计算器”是指该程序设计简洁，功能基础，主要目的是为了帮助那些刚开始学习QT的...
科学计算器VC++源代码_ScienceCalcMFC
12-22
本文将探讨基于VC++开发的科学计算器——ScienceCalcMFC的源代码，揭示其背后的编程原理和技术细节。 首先，ScienceCalcMFC是一款基于Microsoft Foundation Classes (MFC)库的Windows应用程序。MFC是微软为C++...
VC++课程设计（简易计算器）
02-17
【VC++课程设计——简易计算器】是一个典型的编程实践项目，旨在帮助学习者掌握Microsoft Visual C++（VC++）编程环境，以及如何利用C++语言构建一个功能基础的计算器应用程序。这个项目不仅涉及到基本的C++语法，还...
Visual C++ 2005入门经典.part04.rar (整理并添加所有书签)
09-01
9.3 继承机制下的访问控制 9.3.1 派生类中构造函数的操作 9.3.2 声明类的保护成员 9.3.3 继承类成员的访问级别 9.4 派生类中的复制构造函数 9.5 友元类成员 9.5.1 友元类 9.5.2 对类友元关系的限制 9.6 虚函数 9.6.1...
计算器（C++控制台界面）
10-22
C++数据结构实习。使用双栈实现计算器计算功能，除基本运算外，支持幂运算，开方运算和三角函数运算。原创，如有问题请联系我
c++控制台计算器（正则）
12-11
很简单的一个正则计算器，没有GUI，只有+-*/（）
命令行计算器
12-11
命令行计算器，c++标准命令行输入，输出结果
c++学习笔记，一个简单的计算器（控制台）
如果没有如果的博客
02-04 1334
//--------------------------------------【程序说明】------------------------------------------- //开发测试所用操作系统： Windows 7 32bit //开发测试所用IDE版本：Visual Studio 2015 // A program to implement a calcul
C++实现简单计算器功能
eCode代码加工厂
10-06 1万+
利用C++的标准模板库（STL）中的栈（stack）实现一个计算器功能，该计算器模仿Windows系统自带的计算器，输入一串字符（可含括号），得出最终结果。
C++实现计算器
EncodedStar的博客
04-08 1万+
思路：符号和数字进行不同的栈处理，对于判断符号栈中的符号来处理数据，主函数中对于2判断符号使用调用2个函数，巧妙的实现了四则运算，（）的运算。感觉此代码可以学习到很多。逻辑也是很强。希望对写计算器的同学们有帮助
C++实现简单计算器
山重水复疑无路,柳暗花明又一村
01-05 1万+
C++实现简单计算器 要求：输入一个包含+ - * /的非负整数计算表达式，计算表达式的值，每个字符之间需有一个空格，若一行输入为0，则退出程序。 输入样例： 4 + 2 * 5 - 7 / 11 输出样例： 13.36 实现代码： #include #include using namespace std; char str[200];//保存表达式字符串
c++实现的一个控制台下的计算器
IMLCB的专栏
10-09 872
第一次写博客，心情有点小激动呢。本人小菜，学习完了c++，现在刚开始学习数据结构。前两天用c++实现了一个控制台计算器，想我菜鸟也是费了一番周折。废话 不多说
C++计算器实现 ——（完整功能实现、设计分析）
热门推荐
demo_yo的博客
01-07 4万+
基于标准C++的计算器实现。 一、需求实现 1、实现功能： 支持运算符：+, - , *, /, %（百分号）, ^（幂次方）, | |（绝对值），！（阶乘）。其他符号：( ) [ ] { } 支持数据类型：正负数、小数。 2、实现方法 符号优先级处理方法：符号等级制 运算表达式处理方法：后缀表达式法 后缀表达式转换及计算辅助方法：符号栈、数字栈

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值