精华内容
下载资源
问答
  • c++ 计算器
    2020-12-26 10:27:48
    #include<bits/stdc++.h>
    #include <Windows.h>
    using namespace std;
    int main(){
    	int lx,ja,jb,jo,jja,jjb,jjo,ca,cb,co,a,cca,ccb,cco;
    	system("title 泽皓计算器V1.0"); 
    	cout<<"请输入要运算的类型:"<<endl; Sleep(500); 
    	system("color e");
    	cout<<"1 加法计算"<<endl;Sleep(500); 
    	cout<<"2 减法运算"<<endl;Sleep(500); 
    	cout<<"3 乘法计算"<<endl;Sleep(500); 
    	cout<<"4 除法运算"<<endl;Sleep(500); 
    	cin>>lx;
    	// 检查布尔条件
       if( lx == 1 )
       {
           // 如果条件为真,则输出下面的语句
           cout<<"请输入加数"<<endl; 
           cin>>ja;
           cout<<"请输入加数2"<<endl; 
           cin>>jb;
           jo=ja+jb;
           cout<<"运算结果为:"<<jo<<endl;
       }
       else
       {
           // 如果条件为假,则输出下面的语句
           // 检查布尔条件
       if( lx == 2 )
       {
           // 如果条件为真,则输出下面的语句
           cout<<"请输入被减数"<<endl; 
           cin>>jja;
           cout<<"请输入减数"<<endl; 
           cin>>jjb;
           jjo=jja+jjb;
           cout<<"运算结果为:"<<jjo<<endl;
       }
       else
       {
           // 如果条件为假,则输出下面的语句
           // 检查布尔条件
       if( lx == 3 )
       {
           // 如果条件为真,则输出下面的语句
           cout<<"请输入乘数"<<endl; 
           cin>>ca;
           cout<<"请输入乘数2"<<endl; 
           cin>>cb;
           co=ca*cb;
           cout<<"运算结果为:"<<co<<endl;
       }
       else
       {
           // 如果条件为假,则输出下面的语句
           // 检查布尔条件
       if( lx == 4 )
       {
           // 如果条件为真,则输出下面的语句
            cout<<"请输入被除数"<<endl; 
           cin>>cca;
           cout<<"请输入除数"<<endl; 
           cin>>ccb;
           cco=cca/ccb;
           cout<<"运算结果为:"<<cco<<endl;
       }
       else
       {
           // 如果条件为假,则输出下面的语句
           system("color c");
           cout << "错误!" << endl;
       }
       }
       }
       }
    
       
    	return 0;
    } 

     

    更多相关内容
  • C++计算器 Dev-C++

    2021-06-05 08:51:49
    自己编的一个简易计算器,不喜勿喷
  • c++ 计算器

    2017-10-24 12:57:36
    简单易懂 c++ MFC 计算器 适于初学者 只有简单的加减乘除
  • c++计算器程序

    2018-04-03 15:47:37
    C++计算器的完整程序,可以直接打开,功能齐全,希望对你有帮助。
  • C++ 计算器.zip

    2019-09-21 09:03:35
    里面有两个 工程文件 1:c++计算器 的LIB 还有一个是测试的文件 LIB:My_Calc 测试:Cacl
  • c++计算器基本代码.zip

    2021-03-18 16:27:14
    c++计算器基本代码
  • c++计算器源代码

    2014-06-25 19:51:39
    学习计算机或者软件专业的同学会用到的一个比较经典的程序 计算器 可以运行的
  • 湖南工学院 C++面向对象程序设计 课程设计说明书 计算器 专业 班级 姓名 学号 时间 PAGE PAGE # 目录 TOC \o "1-5" \h \z \o "Current Document" 一 课题说明 4 二 设计内容与具体要求 .4 \o "Current Document" 三 ...
  • c++计算器实验报告.doc

    2020-02-26 10:07:56
    PAGE 简单计算器 学号:201321176051 姓名: 周吉祥 实验目的模仿日常生活中所用的计算器自行设计一个简单的计算器程序实现简单的计算功能 实验内容 体系设计 程序是一个简单的计算器能正确输入数据能实现加减乘除等...
  • C++计算器mfc

    2017-03-08 15:19:28
    C++语言实现简单的加、减乘除功能,适合初学者对C++语言学习实践。
  • c++计算器(exe)文件

    2022-02-05 19:39:06
    c++计算器exe文件,直接运行!
  • C++计算器课程设计报告,含有部分代码,真实,调试成功的!
  • c++计算器模板_C++_

    2021-10-01 11:33:29
    C++计算器模板
  • C++计算器实现.zip

    2021-08-20 15:00:00
    C++计算器实现 一、计算器的功能(可计算表达式,包含以下运算): 1、可计算表达式,包含以下运算 (1)四则运算符 +, -, *, / (2)取正、取负 +, - (3)前后缀自增自减 ++, -- (对于变量后缀增与C++规则一致,对于...
  • C++ 计算器

    2012-07-30 21:33:28
    C++ 计算器 第一次运算之后可继续输入计算,直到自己想要结束为止
  • 简单计算器简单计算器简单计算器简单计算器简单计算器简单计算器简单计算器简单计算器
  • C++计算器可视化.rar

    2021-03-20 12:55:13
    基于MFC界面的计算器,可以实现简单的加减乘除,代码简单易懂,下载可以直接运行
  • c++计算器源码

    2016-08-09 23:59:28
    计算器设计一点思路,欢迎大家参孝
  • 我设置了5积分购买,自夸一波,市面上的c++计算器应该没有做得这么认真的,因此它值5积分购买。当然,如有需要,加本人微信hxw---12,或者csdn私聊就行,不收费不收费,不要在这花积分买,笔者有一些没有实现的功能...
  • 一个科学计算器的源程序,包含大部分的科学计算功能。
  • 一个强大的计算器,集合了各种函数,就是界面不漂亮。
  • C++计算器实现 ——(完整功能实现、设计分析)

    万次阅读 多人点赞 2021-01-07 22:58:47
    基于标准C++计算器实现。 一、需求实现 1、实现功能: 支持运算符:+, - , *, /, %(百分号), ^(幂次方), | |(绝对值),!(阶乘)。其他符号:( ) [ ] { } 支持数据类型:正负数、小数。 2、实现方法 符号...

    基于标准C++的计算器实现。

    一、需求实现

    1、实现功能:

    支持运算符:+, - , *, /, %(百分号), ^(幂次方), | |(绝对值),!(阶乘)。其他符号:( ) [ ] { }

    支持数据类型:正负数、小数。

    2、实现方法

    符号优先级处理方法:符号等级制

    运算表达式处理方法:后缀表达式法

    后缀表达式转换及计算辅助方法:符号栈、数字栈

    二、设计实现

    总体设计:

    计算器类

    //计算器类
    class Calculator
    {
    public:
    	Calculator();
    	void getFormat();					//表达式自定义标准格式化
    	int getPrior(char c);				//获取算术符号优先级
    	void getPostfix();					//后缀表达式转换
    	void calResult();					//计算结果
    	void calculate();					//计算方法
    	double getResult();					//获取结果
    
    	string operatorSym;					//运算符号
    	string infix;						//表达式缓存
    
    private:
    	vector<string> postfix;				//后缀表达式向量
    	stack<char> symStack;				//符号栈
    	stack<double> figStack;				//数字栈
    	string stdInfix;					//自定义标准格式化表达式
    	double result;						//最终计算结果
    };
    

    1、运算优先级功能实现

    (1)运算符等级

    声明为枚举常量(在整个类中恒定),便于数据管理、数据与程序分离。

    //算术符号优先权等级
    enum PRIO_LV {
    	PRIO_LV0 = 0,
    	PRIO_LV1 = 1,
    	PRIO_LV2 = 2,
    	PRIO_LV3 = 3,
    	PRIO_LV4 = 4,
    };
    
    (2)运算符优先级获取

    用于运算优先级比较的依据。

    //获取算术符号优先级
    int Calculator::getPrior(char c) {
    
    	if (c == '+' || c == '-') {
    		return PRIO_LV1;
    	}
    	else if (c == '*' || c == '/') {
    		return PRIO_LV2;
    	}
    	else if (c == '%' || c == '^') {
    		return PRIO_LV3;
    	}
    	else if (c == '!') {
    		return PRIO_LV4;
    	}
    	else {
    		return PRIO_LV0;
    	}
    	//else { cout << c << 非法符号! << endl; }
    }
    

    2、绝对值符号奇偶性实现

    //绝对值符号个数的奇偶性
    enum ABS_ODEVITY {
    	ABS_ODD = 1,
    	ABS_EVEN = 2,
    };
    

    3、正负数运算实现

    
    //表达式自定义标准格式化
    void Calculator::getFormat() {
    
    	stdInfix = infix;
    
    	//实现正负数
    	//for (int i = 0; i < stdInfix.length(); i++) {			//string下标调用运算符时可能会导致类型溢出
    	for (size_t i = 0; i < stdInfix.size(); i++) {			//string.size()返回size_type类型,避免下标运算时的类型溢出
    		if (stdInfix[i] == '-' || stdInfix[i] == '+') {		//-x转换为0-x,+x转化为0+x
    			if (i == 0) {
    				stdInfix.insert(0, 1, '0');
    			}
    			else if (stdInfix[i - 1] == '(') {
    				stdInfix.insert(i, 1, '0');
    			}
    		}
    	}
    }
    

    4、后缀表达式转换

    要直接对表达式求值,首先要能够正确解释表达式,或者翻译成能正确求值的一个机器指令序列,以便计算机的处理执行。因此有前缀表达式和后缀表达式方法,此处采用较为广泛的后缀表达式方法。

    //后缀表达式转换
    void Calculator::getPostfix() {
    
    	int absNumeber = ABS_ODD;				//绝对值符号个数的奇偶性
    	string tmp;
    
    	//for (int i = 0; i < stdInfix.length(); i++) {
    	for (size_t i = 0; i < stdInfix.size(); i++) {					//string.size()返回size_type类型,避免下标运算时的类型溢出
    		tmp = "";
    		switch (stdInfix[i]) {
    		case '+':
    		case '-':
    		case '*':
    		case '/':
    		case '%':
    		case '^':
    		case '!':
    			if (symStack.empty() || symStack.top() == '(' || symStack.top() == '[' || symStack.top() == '{' || (symStack.top() == '|' && absNumeber == ABS_ODD)) {
    				symStack.push(stdInfix[i]);
    			}
    			else {
    				while (!symStack.empty() && (getPrior(symStack.top()) >= getPrior(stdInfix[i]))) {
    					tmp += symStack.top();
    					postfix.push_back(tmp);
    					symStack.pop();
    					tmp = "";
    				}
    				symStack.push(stdInfix[i]);
    			}
    			break;
    		case '|':
    			if (absNumeber == ABS_ODD) {
    				symStack.push(stdInfix[i]);
    				absNumeber = ABS_EVEN;
    			}
    			else{
    				while (!symStack.empty() && symStack.top() != '|') {
    					tmp += symStack.top();
    					postfix.push_back(tmp);
    					symStack.pop();
    					tmp = "";
    				}
    				if (!symStack.empty() && symStack.top() == '|') {
    					tmp += symStack.top();
    					postfix.push_back(tmp);						//左绝对值符号'|'加入后缀表达式,用于绝对值的检测计算
    					symStack.pop();
    					absNumeber = ABS_ODD;
    				}
    			}
    			break;
    		case '(':
    		case '[':
    		case '{':
    			symStack.push(stdInfix[i]);
    			break;
    		case ')':
    			while (!symStack.empty() && symStack.top() != '(') {
    				tmp += symStack.top();
    				postfix.push_back(tmp);
    				symStack.pop();
    				tmp = "";
    			}
    			if (!symStack.empty() && symStack.top() == '(') {
    				symStack.pop();							//将左括号出栈丢弃
    			}
    			break;
    		case ']':
    			while (!symStack.empty() && symStack.top() != '[') {
    				tmp += symStack.top();
    				postfix.push_back(tmp);
    				symStack.pop();
    				tmp = "";
    			}
    			if (!symStack.empty() && symStack.top() == '[') {
    				symStack.pop();							//将左括号出栈丢弃
    			}
    			break;
    		case '}':
    			while (!symStack.empty() && symStack.top() != '{') {
    				tmp += symStack.top();
    				postfix.push_back(tmp);
    				symStack.pop();
    				tmp = "";
    			}
    			if (!symStack.empty() && symStack.top() == '{') {
    				symStack.pop();							//将左括号出栈丢弃
    			}
    			break;
    		default:
    			if ((stdInfix[i] >= '0' && stdInfix[i] <= '9')) {
    				tmp += stdInfix[i];
    				while (i + 1 < stdInfix.length() && (stdInfix[i + 1] >= '0' && stdInfix[i + 1] <= '9' || stdInfix[i + 1] == '.')) {		//小数处理
    
    					tmp += stdInfix[i + 1];			//是连续的数字,则追加
    					i++;
    				}
    				if (tmp[tmp.length() - 1] == '.') {
    					tmp += '0';						//将x.做x.0处理
    				}
    				postfix.push_back(tmp);
    			}
    			break;
    		}//end switch
    	}//end for
    
    	//if(!symStack.empty()) {
    	while (!symStack.empty()) {						//将栈中剩余符号加入后缀表达式
    		tmp = "";
    		tmp += symStack.top();
    		postfix.push_back(tmp);
    		symStack.pop();
    	}
    }
    

    5、计算后缀表达式

    计算后缀表达式,得到最终计算结果,将结果传递到计算器类的result属性。

    //计算
    void Calculator::calResult() {
    
    	string tmp;
    	double number = 0;
    	double op1 = 0, op2 = 0;
    
    	for (int i = 0; i < postfix.size(); i++) {
    		tmp = postfix[i];
    		if (tmp[0] >= '0' && tmp[0] <= '9') {
    			number = atof(tmp.c_str());
    			figStack.push(number);
    		}
    		else if (postfix[i] == "+") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(op1 + op2);
    		}
    		else if (postfix[i] == "-") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(op1 - op2);
    		}
    		else if (postfix[i] == "*") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(op1* op2);
    		}
    		else if (postfix[i] == "/") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop(); 
    			}
    			if (op2 != 0) {
    				///除数不为0,未做处理,默认
    			}
    			figStack.push(op1 / op2);
    		}
    		else if (postfix[i] == "%") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(fmod(op1, op2));			//可进行小数求余
    		}
    		else if (postfix[i] == "^") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(pow(op1, op2));
    		}
    		else if (postfix[i] == "|") {
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(abs(op1));
    		}
    		else if (postfix[i] == "!") {
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			if (op1 > 0) {
    				//阶乘数应大于;为小数时(转化为整数求阶)
    				double factorial = 1;
    				for (int i = 1; i <= op1; ++i)
    				{
    					factorial *= i;
    				}
    				op1 = factorial;
    			}
    			figStack.push(op1);
    		}
    	}//end for
    	if (!figStack.empty()) {
    		result = figStack.top();
    	}
    }
    

    6、对象的外部调用方法

    //计算方法
    void Calculator::calculate() {
    
    	getFormat();				//表达式自定义标准格式化
    	getPostfix();				//后缀表达式转换
    	calResult();				//获取算术结果
    }
    
    //获取结果
    double Calculator::getResult() {
    	return result;
    }
    

    三、完整代码

    Calculator.h: 头文件

    //Calculator.h: 头文件
    #include <stack>
    #include <vector>
    #include <string>
    using namespace std;
    
    //计算器类
    class Calculator
    {
    public:
    	Calculator();
    	void getFormat();					//表达式自定义标准格式化
    	int getPrior(char c);				//获取算术符号优先级
    	void getPostfix();					//后缀表达式转换
    	void calResult();					//计算后缀表达式
    	void calculate();					//计算方法
    	double getResult();					//获取结果
    
    	string operatorSym;					//运算符号
    	string infix;						//表达式缓存
    
    private:
    	vector<string> postfix;				//后缀表达式向量
    	stack<char> symStack;				//符号栈
    	stack<double> figStack;				//数字栈
    	string stdInfix;					//自定义标准格式化表达式
    	double result;						//最终计算结果
    };
    

    Calculator.cpp: 实现文件

    //Calculator.cpp: 实现文件
    #include <stack>
    #include <vector>
    #include <string>
    #include <cmath>
    using namespace std;
    
    //绝对值符号个数的奇偶性
    enum ABS_ODEVITY {
    	ABS_ODD = 1,
    	ABS_EVEN = 2,
    };
    
    //算术符号优先权等级
    enum PRIO_LV {
    	PRIO_LV0 = 0,
    	PRIO_LV1 = 1,
    	PRIO_LV2 = 2,
    	PRIO_LV3 = 3,
    	PRIO_LV4 = 4,
    };
    
    Calculator::Calculator() {				//构造函数,初始化成员变量
    
    	operatorSym = "支持运算符:+, - , *, /, %(百分号), ^(幂次方), | |(绝对值),!(阶乘)。其他符号:( ) [ ] { }";
    	result = 0.0;
    }
    
    
    //表达式自定义标准格式化
    void Calculator::getFormat() {
    
    	stdInfix = infix;
    
    	//实现正负数
    	//for (int i = 0; i < stdInfix.length(); i++) {					//string下标调用运算符时可能会导致类型溢出
    	for (size_t i = 0; i < stdInfix.size(); i++) {					//string.size()返回size_type类型,避免下标运算时的类型溢出
    		if (stdInfix[i] == '-' || stdInfix[i] == '+') {				//-x转换为0-x,+x转化为0+x
    			if (i == 0) {
    				stdInfix.insert(0, 1, '0');
    			}
    			else if (stdInfix[i - 1] == '(') {
    				stdInfix.insert(i, 1, '0');
    			}
    		}
    	}
    }
    
    //获取算术符号优先级
    int Calculator::getPrior(char c) {
    
    	if (c == '+' || c == '-') {
    		return PRIO_LV1;
    	}
    	else if (c == '*' || c == '/') {
    		return PRIO_LV2;
    	}
    	else if (c == '%' || c == '^') {
    		return PRIO_LV3;
    	}
    	else if (c == '!') {
    		return PRIO_LV4;
    	}
    	else {
    		return PRIO_LV0;
    	}
    	//else { cout << c << 非法符号! << endl; }
    }
    
    //后缀表达式转换
    void Calculator::getPostfix() {
    
    	int absNumeber = ABS_ODD;				//绝对值符号个数的奇偶性
    	string tmp;
    
    	//for (int i = 0; i < stdInfix.length(); i++) {
    	for (size_t i = 0; i < stdInfix.size(); i++) {					//string.size()返回size_type类型,避免下标运算时的类型溢出
    		tmp = "";
    		switch (stdInfix[i]) {
    		case '+':
    		case '-':
    		case '*':
    		case '/':
    		case '%':
    		case '^':
    		case '!':
    			if (symStack.empty() || symStack.top() == '(' || symStack.top() == '[' || symStack.top() == '{' || (symStack.top() == '|' && absNumeber == ABS_ODD)) {
    				symStack.push(stdInfix[i]);
    			}
    			else {
    				while (!symStack.empty() && (getPrior(symStack.top()) >= getPrior(stdInfix[i]))) {
    					tmp += symStack.top();
    					postfix.push_back(tmp);
    					symStack.pop();
    					tmp = "";
    				}
    				symStack.push(stdInfix[i]);
    			}
    			break;
    		case '|':
    			if (absNumeber == ABS_ODD) {
    				symStack.push(stdInfix[i]);
    				absNumeber = ABS_EVEN;
    			}
    			else{
    				while (!symStack.empty() && symStack.top() != '|') {
    					tmp += symStack.top();
    					postfix.push_back(tmp);
    					symStack.pop();
    					tmp = "";
    				}
    				if (!symStack.empty() && symStack.top() == '|') {
    					tmp += symStack.top();
    					postfix.push_back(tmp);						//左绝对值符号'|'加入后缀表达式,用于绝对值的检测计算
    					symStack.pop();
    					absNumeber = ABS_ODD;
    				}
    			}
    			break;
    		case '(':
    		case '[':
    		case '{':
    			symStack.push(stdInfix[i]);
    			break;
    		case ')':
    			while (!symStack.empty() && symStack.top() != '(') {
    				tmp += symStack.top();
    				postfix.push_back(tmp);
    				symStack.pop();
    				tmp = "";
    			}
    			if (!symStack.empty() && symStack.top() == '(') {
    				symStack.pop();							//将左括号出栈丢弃
    			}
    			break;
    		case ']':
    			while (!symStack.empty() && symStack.top() != '[') {
    				tmp += symStack.top();
    				postfix.push_back(tmp);
    				symStack.pop();
    				tmp = "";
    			}
    			if (!symStack.empty() && symStack.top() == '[') {
    				symStack.pop();							//将左括号出栈丢弃
    			}
    			break;
    		case '}':
    			while (!symStack.empty() && symStack.top() != '{') {
    				tmp += symStack.top();
    				postfix.push_back(tmp);
    				symStack.pop();
    				tmp = "";
    			}
    			if (!symStack.empty() && symStack.top() == '{') {
    				symStack.pop();							//将左括号出栈丢弃
    			}
    			break;
    		default:
    			if ((stdInfix[i] >= '0' && stdInfix[i] <= '9')) {
    				tmp += stdInfix[i];
    				while (i + 1 < stdInfix.length() && (stdInfix[i + 1] >= '0' && stdInfix[i + 1] <= '9' || stdInfix[i + 1] == '.')) {		//小数处理
    
    					tmp += stdInfix[i + 1];			//是连续的数字,则追加
    					i++;
    				}
    				if (tmp[tmp.length() - 1] == '.') {
    					tmp += '0';						//将x.做x.0处理
    				}
    				postfix.push_back(tmp);
    			}
    			break;
    		}//end switch
    	}//end for
    
    	//if(!symStack.empty()) {
    	while (!symStack.empty()) {						//将栈中剩余符号加入后缀表达式
    		tmp = "";
    		tmp += symStack.top();
    		postfix.push_back(tmp);
    		symStack.pop();
    	}
    }
    
    //计算后缀表达式
    void Calculator::calResult() {
    
    	string tmp;
    	double number = 0;
    	double op1 = 0, op2 = 0;
    
    	for (int i = 0; i < postfix.size(); i++) {
    		tmp = postfix[i];
    		if (tmp[0] >= '0' && tmp[0] <= '9') {
    			number = atof(tmp.c_str());
    			figStack.push(number);
    		}
    		else if (postfix[i] == "+") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(op1 + op2);
    		}
    		else if (postfix[i] == "-") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(op1 - op2);
    		}
    		else if (postfix[i] == "*") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(op1* op2);
    		}
    		else if (postfix[i] == "/") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop(); 
    			}
    			if (op2 != 0) {
    				///除数不为0,未做处理,默认
    			}
    			figStack.push(op1 / op2);
    		}
    		else if (postfix[i] == "%") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(fmod(op1, op2));			//可进行小数求余
    		}
    		else if (postfix[i] == "^") {
    			if (!figStack.empty()) {
    				op2 = figStack.top();
    				figStack.pop();
    			}
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(pow(op1, op2));
    		}
    		else if (postfix[i] == "|") {
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			figStack.push(abs(op1));
    		}
    		else if (postfix[i] == "!") {
    			if (!figStack.empty()) {
    				op1 = figStack.top();
    				figStack.pop();
    			}
    			if (op1 > 0) {
    				//阶乘数应大于;为小数时(转化为整数求阶)
    				double factorial = 1;
    				for (int i = 1; i <= op1; ++i)
    				{
    					factorial *= i;
    				}
    				op1 = factorial;
    			}
    			figStack.push(op1);
    		}
    	}//end for
    	if (!figStack.empty()) {
    		result = figStack.top();
    	}
    }
    
    //计算方法
    void Calculator::calculate() {
    
    	getFormat();				//表达式自定义标准格式化
    	getPostfix();				//后缀表达式转换
    	calResult();				//获取算术结果
    }
    
    //获取结果
    double Calculator::getResult() {
    	return result;
    }
    

    Main.cpp:主程序

    #include <iostream>
    using namespace std;
    
    //const int MAX_EXP_LEN = 1000;			//最大表达式长度	防止内存溢出
    
    //main函数
    int main()
    {
    	Calculator cal;
    	cout << cal.operatorSym << endl;
    	cout << "----------" << endl;
    
    	while (true) {
    		getline(cin, cal.infix);
    		/*
    		if (cal.infix.length() > MAX_EXP_LEN) {
    			cout << "超出最大长度!" << endl;
    			system("pause");
    		}
    		else {
    			cal.calculate();
    		}
    		*/
    		cal.calculate();
    		cout << cal.getResult() << endl;
    	}
    	return 0;
    }
    

    资源获取

    展开全文
  • Antlr4 C++ 计算器

    2020-09-30 06:53:25
    使用C++实现了《ANTLR4权威指南》中第三章的计算器,代码中已经包含了ANTLR4 运行时代码,不需要额外安装
  • c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器
  • 使用C++语言,使用动态链表实现大数之间四则运算
  • c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器
  • c++计算器课程设计

    2018-01-26 19:02:58
    c++计算器 课程设计,希望对课设或者c++学习者有帮助!!...............................................................................

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,314
精华内容 10,525
关键字:

c++ 计算器