精华内容
下载资源
问答
  • MFC计算器c++编写

    2019-01-09 09:29:09
    利用表达式后缀表达式计算结果,适用于初次学习c++的同学们,代码量有点多,看起来比较头疼,很多可能看不懂,大多数是结构是书上的
  • 代码要用VS2017跑。可以从界面使用键盘输入或鼠标点击按钮输入算式,可以实现加减乘除括号运算,还具有sin,cos等一元运算操作,操作数可以为负数。
  • 程序是使用MFC实现计算器的功能,能进行的运算由加减乘除、指数运算、开方运算等,支持连续输入,栈是自己编写的,是初学数据结构于MFC很好的例子。
  • MFC 计算器

    2017-11-24 14:15:44
    和平时所用计算器一样,能进行+ - * / 平方 开方 AC 回退 等功能,代码简单。有注释!!!在VS2015编译运行的,VC6.0改一下配置参数也可以运行。
  • MFC计算器MFC计算器MFC计算器MFC计算器
  • 实现了加减乘除、开方、取余、连算等功能,含有详细实现文档,修复了所有的bug。
  • MFC 计算器小程序

    2020-10-03 18:06:36
    MFC写的一个简单的计算器程序的源代码,含有多种数学函数,同时含有括号功能,可以计算较为复杂算式的计算。开发环境是Visual Studio 2019 专业版
  • MFC计算器.zip

    2020-10-03 12:28:37
    MFC计算器
  • mfc计算器.zip

    2020-04-03 16:26:48
    vc6 mfc开发的计算器 p
  • MFC计算器模板

    2018-09-21 23:19:20
    该压缩包为MFC简单的输入输出,大概给了一个win32程序样子,带有注释,希望大家能看懂
  • C++ MFC计算器

    2018-12-24 20:32:54
    自己用MFC基础类实现的一个简单的C++ MfC计算器。可以实现一些基本的加、减、乘、除运算
  • VC6.0 MFC 计算器.zip

    2020-04-27 20:51:57
    计算器 *输入一个算式(包括操作数(整型、浮点数)、操作符、优先符) *对算式进行编译,确定操作数、操作符、运算次序 *给出可计算的测试算式 支持各种进制转换(2、8、10、16) *选择一种进制,输入一个合法...
  • mfc 计算器

    2014-04-08 14:47:32
    基于mfc的简单的计算器,适合新手参考,可能有bug。
  • mfc实现一个简单的计算器,本人在短学期学习接触MFC,自行学习变成了一个简单的计算器,不过具体的外观细节以及功能还得加强
  • mfc计算器,数据结构实验……实现科学计算器的功能。
  • VS2010 MFC计算器

    2018-08-02 14:23:51
    MFC计算法,可在vs2010下进行编辑,mfc界面难看,但是展示了 带括号的计算器,可支持的运算加减乘除及乘方 +-*、^, 主要学习计算器的优先级带括号之类的操作
  • 这个计算器设计利用了VC++6.0的MFC框架实现了windows窗口程序的多样性和实用性,巧妙地展现了C++程序语言的面向对象性,程序简洁但功能齐全。 关键算法为实现加减乘除等算法以及调用了开方函数和科学计算方法等。
  • mfc计算器实现

    千次阅读 多人点赞 2021-01-08 00:16:23
    基于vs和标准C++的MFC计算器实现。 一、需求实现 1、功能 数据类型:正负数、小数。 非特殊功能(运算功能):+, - , *, /, %(百分号), ^(幂次方), | |(绝对值),!(阶乘)。其他符号:( ) 特殊功能:C(清0...

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

    一、需求实现

    1、功能

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

    非特殊功能(运算功能):+, - , *, /, %(百分号), ^(幂次方), | |(绝对值),!(阶乘)。其他符号:( )

    特殊功能:C(清0),delete(退格),=(计算并显示结果)

    2、方法

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

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

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

    3、用户界面

    在这里插入图片描述

    二、设计实现

    这里主要讲解,MFC应用的实现。

    1、MFC用户界面设计

    输入区:Edit Control 控件
    输出区:Static Text 控件
    按钮区:Button 控件

    2、MFC用户界面事件响应

    (1)非特殊功能按钮 - 事件处理

    自定义函数用于处理按钮操作时,向输入区追加按钮文本内容。实现非功能按钮事件的代码复用。

    //MFC_CalculatorDlg.cpp: 实现文件
    
    // 输入区显示按钮操作
    void CMFCCalculatorDlg::AddToEditExp(UINT IDC_Button)
    {
    	CString strBtn;
    	CString strExp;
    	GetDlgItem(IDC_Button)->GetWindowText(strBtn);
    	GetDlgItem(IDC_EDIT_EXP)->GetWindowText(strExp);
    	SetDlgItemText(IDC_EDIT_EXP, strExp + strBtn);
    }
    

    数字、数字符号、运算表达式符号,为非特殊功能区,只为向输入区显示输入内容,无特殊功能。
    其按钮事件处理如下: ------(只列出‘+’和’0’按钮事件处理,其他同理)

    //‘+’加法,按钮事件处理
    void CMFCCalculatorDlg::OnBnClickedButtonAdd()
    {
    	//调用自定义处理函数,传递‘+’按钮句柄
    	AddToEditExp(IDC_BUTTON_ADD);
    }
    
    //‘0’数字,按钮事件处理
    void CMFCCalculatorDlg::OnBnClickedButton0()
    {
    	AddToEditExp(IDC_BUTTON_0);
    }
    
    (2)特殊功能按钮 - 事件处理

    ‘C’清0,按钮事件处理

    // ‘C/CE’清0,按钮事件处理
    void CMFCCalculatorDlg::OnBnClickedButtonClear()
    {
    	SetDlgItemText(IDC_EDIT_EXP, NULL);
    	CString cstr;
    	cstr = "0";
    	SetDlgItemText(IDC_STATIC_RESULT, cstr);
    }
    

    ‘delete’退格,按钮事件处理

    // ‘delete’退格,按钮事件处理
    void CMFCCalculatorDlg::OnBnClickedButtonDelete()
    {
    	CString strExp;
    	GetDlgItem(IDC_EDIT_EXP)->GetWindowText(strExp);
    	strExp = strExp.Left(strExp.GetLength() - 1);
    	SetDlgItemText(IDC_EDIT_EXP, strExp);
    }
    

    ‘=’等于,按钮事件处理

    //‘=’等于,按钮事件处理
    void CMFCCalculatorDlg::OnBnClickedButtonEqual()
    {
    	CString strExp;
    	Calculator cal;		//外部计算类
    	CString cstr_Result;
    	CString cstr_ErrorInfo;
    
    	GetDlgItem(IDC_EDIT_EXP)->GetWindowText(strExp);
    	string infix(CW2A(strExp.GetString()));
    	cal.calculate(infix);
    	cstr_Result.Format(_T("%f"), cal.getResult());
    	
    	//可用于外部计算类的异常信息传递到mfc用户界面	
    	/*
    	*cstr_ErrorInfo + cal.getErrorImfo().c_str();
    	*if (!cstr_ErrorInfo.IsEmpty()) {
    	*	SetDlgItemText(IDC_STATIC_RESULT, cstr_ErrorInfo);
    	*}
    	*/
    	
    	//输出区显示计算结果
    	SetDlgItemText(IDC_STATIC_RESULT, cstr_Result);
    }
    

    3、外部计算器类(计算方法类)

    Caculator.h: 头文件

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

    Caculator.cpp: 实现文件

    //Caculator.cpp: 实现文件
    #include "pch.h"
    #include "Calculator.h"
    
    #include <stack>
    #include <vector>
    #include <string>
    #include <cmath>
    
    //const int MAX_EXP_LEN = 100;			//最大表达式长度
    
    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() {				//构造函数,初始化成员变量
    
    	result = 0.0;
    	//cal_ErrorImfo = "";
    }
    
    
    //表达式自定义标准格式化
    void Calculator::getFormat(string infix) {
    
    	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(string infix) {
    	getFormat(infix);			//表达式自定义标准格式化
    	getPostfix();				//后缀表达式转换
    	calResult();				//计算结果
    }
    
    //获取结果
    double Calculator::getResult() {
    	return result;
    }
    
    /*
    //获取异常信息
    string Calculator::getErrorImfo() {
    	return cal_ErrorImfo;
    }
    */
    

    资源获取

    关于外部计算器类(计算方法类)的具体设计分析 请转 C++计算器实现 ——(完整功能实现、设计分析)

    关于整个MFC_Caculator的程序包 及 项目设计说明书(含总结) 下载地址:MFC_Calculator.rar

    可关注博主在下方留言或私信获取。

    MFC_Caculator项目:
    在这里插入图片描述

    展开全文
  • 这是简单的VC++基于MFC计算器,直接解压放入Visual C++ 6.0或者相关的编译器的工作空间,发开工作空间即可使用编译,目前能够实现的计算功能有整型数据的加减乘除和取反。
  • PAGE / NUMPAGES // Calculator_17483Dlg.cpp : implementation file // #include "stdafx.h" #include "Calculator_17483.h" #include "Calculator_17483Dlg.h" #include "afxdialogex.h" #ifdef _DEBUG #define ne
  • 基于mfc计算器设计步骤及课程设计报告
  • MFC计算器实验报告

    2011-05-03 20:04:05
    使用MFC实现计算器的实验报告,其中包括对数字按钮的响应函数的编写和运算符按钮的响应函数的编写。
  • 实现了加减乘除、开方、取余、连算等功能,含有详细实现文档,修复了所以bug。
  • MFC计算器源码+动态库源码,打开计算器之后,用VC打开计算器.dsw,编译,运行之后,会出一个缺少动态库的提示,把该文件夹下的jsp.dll拷贝到Debug下再次运行程序
  • MFC计算器源代码

    热门讨论 2013-09-17 23:50:16
    MFC计算器源代码,有什么不懂的可以随时到我的博客留言http://www.gymsaga.com/,我会尽早解答您的问题,更多MFC实例讲解,请登陆我的博客。
  • mfc实现计算器

    2017-11-20 20:57:55
    简单实现计算器的加减乘除功能,Win32的程序开发,。。。
  • MFC 计算器源代码

    2015-07-08 17:25:49
    MFC 计算器源代码,支持基本的 + - * / 以及退格等功能,另外可以自行设置各个文本框的字体和整个窗体的颜色,等等。 另外可以根据MFC 计算器源代码的设计过程文档,自行扩展功能。
  • MFC计算器程序

    2014-07-10 16:30:21
    MFC 制作的计算器 具有 存储功能 存储功能有三角函数

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,255
精华内容 2,102
关键字:

mfc计算器