精华内容
下载资源
问答
  • 科学计算器 计算器

    热门讨论 2008-09-11 23:08:01
    显示数据可自由选择是否加千位分隔,小数精度也可自由确定显示 数。并修改了数据转换为"人民币中文大写形式、人民币数字形式(例如:1435.75、人民币壹 仟肆佰叁拾伍圆柒角伍分、¥1435.75)的一些BUG,大大...
  • 计算器可进行多种科学与逻辑运算、公式运算、个人所得税计算、各种单位换算,增加了各种常用常数表,加入了角度与弧度计算,功能非常强大,是工程建筑、科学计算、理财等各方面应用的得力助手!对程序设计和游戏...
  • 简易计算器

    2013-05-01 10:37:36
    提示:可使用两组命令按钮控件数组分别用来输入操作数和操作。作业要求:请参考windows计算器功能,根据自己的情况实现下面部分或全部功能,也可以发挥。 (1)可以利用上一步的运算结果 (2)可以在不点击“=”的...
  • ) 增加了表达式计算的功能,从此可以进行复杂的公式计算,如输入以下公式“2+(18-10)/7^2+sin(1)+sqrt(sqrt(5),3)*2”,计算按钮或回车会自动得出最终结果。另外增加了一个“单步求解”的选项,可以一步一步...
  • 805881_语音计算器

    2011-08-19 20:15:29
    计算器可进行多种科学与逻辑运算、公式运算、个人所得税计算、各种单位换算,增加了各种常用常数表,加入了角度与弧度计算,功能非常强大,是工程建筑、科学计算、理财等各方面应用的得力助手!对程序设计和游戏...
  • 简单计算器的实现

    2017-07-08 21:54:00
    计算器 问题描写叙述: 输入一个简单四则运算表达式字符串,计算该表达式的值 ...3、要考虑加减乘除通常四则运算规定的计算优先级 4、除法用整数除法,即仅保留除法运算结果的整数部分。比方80/3...

    计算器

    问题描写叙述: 输入一个简单四则运算表达式字符串,计算该表达式的值 


    注: 
    1、表达式仅仅含 +, -, *, /, (, ), 四则运算符 
    2、表达式数值仅仅包括整数(0-9),每一个操作数能够是多位。且不会出现0作为除数的情况 
    3、要考虑加减乘除按通常四则运算规定的计算优先级 
    4、除法用整数除法,即仅保留除法运算结果的整数部分。比方80/3=26。

    输入表达式保证无0作为除数情况发生 
    5、输入字符串一定是符合题意合法的表达式,当中仅仅包含数字字符和四则运算符字符。除此之外不含其他不论什么字符,不会出现计算溢出情况


    要求实现函数:  
    int calculate(int len,char *expStr) 


    【输入】 int len: 字符串长度; char *expStr: 表达式字符串。 
    【输出】 无 
    【返回】 计算结果  
    • 演示样例  
    1) 输入:char *expStr = “-3*(-200)-(-3*(-5-2*10)/(4+3-17)*9)” 

          函数返回:663
    2) 输入:char *expStr = “8/3*3”

          函数返回:6



    #include "stdafx.h"
    #include<vector>
    #include<deque>
    #include<iostream>
    using namespace std;
    
    
    char*vec2char(vector<char>vec, char*str)
    {
    	char*s = str;
    	vector<char>::iterator it;
    	it = vec.begin();
    	while (it != vec.end())
    		*(s++) = *(it++);
    	*s = '\0';
    	return str;
    }
    
    //计算不带括号的表达式的值
    int calculate_without_bracket(vector<char>&substr)
    {
    	vector<char>::iterator it, it1, it2, iter;
    	char*str = new char[100];
    	it = substr.begin();
    	while (it != substr.end())
    	{
    		deque<int>bb;
    		deque<int>::iterator p;
    		int aa;
    		//由于每次去括号时,都会对多个“-”
    		//号进行合并,这里不会出现多于两个“-”相连的情况
    		if (*substr.begin() == '-')
    		{
    			if (*(substr.begin() + 1) == '-')
    			{
    				substr.erase(substr.begin(), substr.begin() + 2);
    				it = substr.begin();
    			}
    		}
    		if (*it == '*' || *it == '/')
    		{
    			bool flag1 = false;
    			bool flag2 = false;
    			int f1 = 0, f2 = 0;
    			it1 = it - 1;
    
    			int gg = 0;
    			while (*it1 - '0' >= 0 && *it1 - '0' <= 9 && it1 - substr.begin() >= 0)
    			{
    				gg++;
    				bb.push_front(*it1 - '0');
    				if (it1 == substr.begin())
    					break;
    				it1--;
    			}
    			if (it1 != substr.begin())
    			{
    				if (*it1 == '-')
    				{
    					if (*(it1 - 1) == '-')
    						if (it1 - 1 == substr.begin())
    						{
    							substr.erase(substr.begin(), substr.begin() + 2);
    							it = substr.begin() + gg;
    							it1 = substr.begin();
    						}
    						else
    						{
    							it1 = it1 - 2;
    							substr.erase(it1 + 1, it1 + 3);
    							substr.insert(it1 + 1, '+');
    							it1 = it1 + 2;
    							it = it1 + gg;
    						}
    					else if (*(it1 - 1) == '+')//这一次的乘除运算之前不可能出现别的“*”或“/”
    					{
    						it1 = it1 - 2;
    						substr.erase(it1 + 1, it1 + 3);
    						substr.insert(it1 + 1, '-');
    						it1 = it1 + 2;
    						it = it1 + gg;
    					}
    					else
    						it1++;
    				}
    
    			}
    			else if (it1 == substr.begin() && *it1 == '-')
    				it1++;
    			it2 = it + 1;
    			if (*it2 == '-')
    			{
    				flag1 = true;
    				it2++;
    			}
    			p = bb.begin();
    			while (p != bb.end())
    			{
    				f1 = *p + 10 * f1;
    				++p;
    			}
    			while (it2 != substr.end() && *it2 - '0' >= 0 && *it2 - '0' <= 9)
    			{
    				f2 = 10 * f2 + (*it2 - '0');
    				it2++;
    			}
    			if (*it == '*')
    				aa = f1*f2;
    			else
    				aa = f1 / f2;
    			if (flag1)
    				aa = -aa;
    			char*ss = new char[100];
    			_itoa(aa, ss, 10);
    			if (it1 == substr.begin())
    			{
    				int c = 0;
    				substr.erase(it1, it2);
    				while (*ss != '\0')
    				{
    					substr.insert(substr.begin() + c, *ss);
    					++ss;
    					++c;
    				}
    				it = substr.begin();
    			}
    			else
    			{
    				int c = 0;
    				iter = it1 - 1;
    				substr.erase(it1, it2);
    				while (*ss != '\0')
    				{
    					substr.insert(iter + 1 + c, *ss);
    					++ss;
    					++c;
    				}
    				//substr.insert(iter + 1, aa+'0');
    				it = iter + 1;
    			}
    		}
    		else
    		{
    
    			it++;
    		}
    		//if (substr.size() == 1)
    		// return (*substr.begin() - '0');
    	}
    	it = substr.begin();
    	while (it != substr.end())
    	{
    
    		deque<int>bb;
    		deque<int>::iterator p;
    		int aa;
    		if (*substr.begin() == '-')
    		{
    			if (*(substr.begin() + 1) == '-')
    			{
    				substr.erase(substr.begin(), substr.begin() + 2);
    
    			}
    			else
    			{
    				bool flag2 = false;
    				int f1 = 0, f2 = 0;
    				it1 = substr.begin() + 1;
    
    				while (*it1 - '0' >= 0 && *it1 - '0' <= 9)
    				{
    					bb.push_back(*it1 - '0');
    					it1++;
    					if (it1 == substr.end())
    					{
    						char*src = new char[100];
    						return atoi(vec2char(substr, src));
    					}
    				}
    
    				p = bb.begin();
    				while (p != bb.end())
    				{
    					f1 = *p + 10 * f1;
    					++p;
    				}
    				it = it1;
    				it2 = it + 1;
    				if (*it2 == '-')//由于每次去括号时,都会对多个“-”
    					//号进行合并,这里不会出现多于两个“-”相连的情况
    				{
    					it2++;
    					flag2 = true;
    				}
    				while (it2 != substr.end() && *it2 - '0' >= 0 && *it2 - '0' <= 9)
    				{
    					f2 = 10 * f2 + (*it2 - '0');
    					it2++;
    				}
    				if (*it == '+')
    					if (flag2)
    						aa = -f1 - f2;
    					else
    						aa = -f1 + f2;
    				else
    					if (flag2)
    						aa = -f1 + f2;
    					else
    						aa = -f1 - f2;
    				char*ss = new char[100];
    				_itoa(aa, ss, 10);
    				int c = 0;
    				substr.erase(substr.begin(), it2);
    				while (*ss != '\0')
    				{
    					substr.insert(substr.begin() + c, *ss);
    					++ss;
    					++c;
    				}
    				//substr.insert(substr.begin(), aa + '0');
    				it = substr.begin();
    
    			}
    		}
    		else if
    			//由于每次都是从左到右一次仅仅计算两个数,除了第一个符号是“-”外。还有一种
    			//情况下第一个操作数一定是正数。仅仅需考虑第二个操作数的符号
    			(*it == '+' || *it == '-')
    		{
    			bool flag1 = false;
    			int f1 = 0, f2 = 0;
    			it1 = it - 1;
    			it2 = it + 1;
    			if (*it2 == '-')
    			{
    				flag1 = true;
    				it2++;
    			}
    			while (*it1 - '0' >= 0 && *it1 - '0' <= 9 && it1 - substr.begin() >= 0)
    			{
    				bb.push_front(*it1 - '0');
    				if (it1 == substr.begin())
    					break;
    				it1--;
    			}
    			if (it1 != substr.begin())
    				it1++;
    			p = bb.begin();
    			while (p != bb.end())
    			{
    				f1 = *p + 10 * f1;
    				++p;
    			}
    			while (it2 != substr.end() && *it2 - '0' >= 0 && *it2 - '0' <= 9)
    			{
    				f2 = 10 * f2 + (*it2 - '0');
    				it2++;
    			}
    			if (*it == '+')
    				if (flag1)
    					aa = f1 - f2;
    				else
    					aa = f1 + f2;
    			else
    				if (flag1)
    					aa = f1 + f2;
    				else
    					aa = f1 - f2;
    			char*ss = new char[100];
    			_itoa(aa, ss, 10);
    			if (it1 == substr.begin())
    			{
    				int c = 0;
    				substr.erase(it1, it2);
    				while (*ss != '\0')
    				{
    					substr.insert(substr.begin() + c, *ss);
    					++ss;
    					++c;
    				}
    				//substr.insert(substr.begin(), aa + '0');
    				it = substr.begin();
    			}
    			else
    			{
    				//iter = it - 2;
    				//substr.erase(it - 1, it + 2);
    				//substr.insert(iter + 1, aa + '0');
    				//it = iter + 1;
    				int c = 0;
    				iter = it1 - 1;
    				substr.erase(it1, it2);
    				while (*ss != '\0')
    				{
    					substr.insert(iter + 1 + c, *ss);
    					++ss;
    					++c;
    				}
    				it = iter + 1;
    			}
    
    		}
    		else
    		{
    			it++;
    		}
    	}
    
    	return atoi(vec2char(substr, str));
    }
    
    
    
    
    
    //去括号,每次找到第一对连续匹配的括号。然后用calculate_without_bracket函数
    //计算括号中的表达式的值。计算后的结果插入原表达式,返回true。
    //假设原表达式没有括号,返回false
    bool erase_bracket(vector<char>&str)
    {
    	int size = str.size();
    	bool flag = false;
    	int k = 0;
    	int m, n;
    	vector<char>::iterator it, it1, it2;
    	it = str.begin();
    	while (k < size)
    	{
    		if (str[k] == '(')
    		{
    			m = k;
    			k++;
    			while (str[k] != '('&&str[k] != ')')
    				k++;
    			if (str[k] == ')')
    			{
    				n = k;
    				flag = true;
    				break;
    			}
    			else if (str[k] == '(')
    			{
    				k--;
    			}
    			
    		}
    		else
    		{
    			k++;
    		}
    	}
    	if (flag)
    	{
    		vector<char>sub;
    		for (int i = m+1; i < n ; i++)
    			sub.push_back(str[i]);
    		calculate_without_bracket(sub);
    		it = it + m - 1;
    		for (int i = 0; i < n + 1 - m;i++)
    		str.erase(it + 1, (it + 2 ));
    		int k = 0;
    		int len = sub.size();
    		while (k < len)
    		{
    			str.insert(it + k + 1, sub[k]);
    			k++;
    		}
    	}
    
    	return flag;
    }
    
    
    
    /*vector<char>char2vec(vector<char>&vec, char*str)
    {
    	while (*str != '\0')
    	{
    		vec.push_back(*str);
    		++str;
    	}
    	return vec;
    }*/
    
    
    //总体表达式计算函数,每次调用erase_bracket函数先计算括号中的值
    //直到消除全部的括号。最后调用calculate_without_bracket计算剩下的无括号表达式的值
    int calculate(int len, char *expStr)
    {
    	vector<char>str;
    	for (int i = 0; i < len; i++)
    		str.push_back(expStr[i]);
    	bool flag = true;
    
    	while (flag)
    	{
    		flag = erase_bracket(str);
    	}
    
    	return calculate_without_bracket(str);
    
    }
    
    
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	/*vector<int>aa;
    	vector<int>::iterator it,ite;
    	for (int i = 0; i < 5; i++)
    	aa.push_back(i);
    	it = aa.begin()+3;
    	ite = it -2;
    	aa.erase(it-1,it+1);
    	aa.insert(ite+1, 9);*/
    
    
    	vector<char>vec;
    	//char2vec(vec, "2+10-30-2*9/4+3-7*9");
    	//cout << calculate_without_bracket(vec) << endl;
    	//int len=strlen("2+(5-14-2)*9/(4+3-17)*9");
    	int len = strlen("-3*(-200)-(-3*(-5-2*10)/(4+3-17)*9)");
    	cout << calculate(len, "-3*(-200)-(-3*(-5-2*10)/(4+3-17)*9)");
    
    	system("pause");
    	return 0;
    }


    转载于:https://www.cnblogs.com/lytwajue/p/7138164.html

    展开全文
  • 表达式计算器1

    2013-12-11 18:19:17
    //根据操作的不同执行相应的计算 tResult.Text = dblresult.ToString(); dblacc = dblresult; break; //将计算结果赋给被操作数,以便执行连续的第二次操作 case "+-": if (tResult.Text.Substring(0, 1) =...
  • 还在为需要一个一个用鼠标点按钮输入算式的计算器烦恼吗?没关系,有了这个软件,您大可以把算式按照自然方式整个输入完整后再计算。 软件支持带有大括号、中括号、小括号的算式的加、减、乘、除、指数、阶乘以及...
  • 对于加减乘除四则运算按键,事件触发后的处理是在label标签中显示相应的四则运算,是清屏label标签的,了“=”按键才开始运算并显示结果。 程序使用时是先把整个运算的式子输入到两个计数器中,程序把这一表达式...
  • <br>9、“常规”选项卡中的“使用分隔”选项,是指用户在主程序的输入框中输入数据或通过计算得出数据时,每三数字自动添加一个分隔。 <br>10、“常规”选项卡中的“启用汉字金额显示”选项,是指用户...
  • 5.4.2 按位逻辑操作 93 5.4.3 自增、自减操作 94 5.4.4 关系操作、相等性操作与逻辑操作 95 5.4.5 移位操作 96 5.4.6 圆括号操作 97 5.5 sizeof操作 98 5.6 投射操作 99 5.7 本章小结 101...
  • 2.9.4 按位not运算符 71 2.9.5 移位运算符 71 2.10 lvalue和rvalue 73 2.11 了解存储时间和作用域 74 2.11.1 自动变量 74 2.11.2 决定变量声明的位置 76 2.11.3 全局变量 77 2.11.4 静态变量 80 2.12 名称...
  • 2.9.1 按位and运算符 68 2.9.2 按位or运算符 69 2.9.3 按位eor运算符 71 2.9.4 按位not运算符 71 2.9.5 移位运算符 71 2.10 lvalue和rvalue 73 2.11 了解存储时间和作用域 74 2.11.1 自动变量 74 2.11.2 决定变量...
  • 会计理论考试题

    2012-03-07 21:04:40
    14.选择“重新启动计算机并切换到MS-DOS方式”,在DOS提示下键入“VER”,屏幕显示____D____。 A、DOS6.22 B、DOS7.0 C、Windows3.2 D、Windows98 15.计算机病毒主要破坏计算机系统的 ___C__ 。 A、显示器 B、软盘...
  • 明日科技C#开发入门及项目实战

    热门讨论 2013-04-19 15:47:07
    实例021 巧用移运算符获取汉字编码值 实例022 使用异或运算符对数字进行加密 第3章 流程控制语句 实例023 利用if…else语句判断分数是否及格 实例024 利用switch语句判断时间 实例025 利用while语句判断大小 实例...
  • AddBufDat 对内存内容字节累加求和,通常用于计算校验 Update 界面刷新 ShowMessage 消息窗口 ShowLeftTools 显示左边工具栏 ShowRightTools 显示右边工具栏 ShowTerminal 显示终端窗口 HideLeftTools 隐藏左边...
  • 2.9.1 按位AND运算符 68 2.9.2 按位OR运算符 69 2.9.3 按位EOR运算符 71 2.9.4 按位NOT运算符 71 2.9.5 移位运算符 71 2.10 lvalue和rvalue 73 2.11 了解存储时间和作用域 74 2.11.1 自动变量 74 2.11.2 ...
  • 实例021 巧用移运算符获取汉字编码值 30 实例022 使用异或运算符对数字进行加密 31 第3章 流程控制语句 33 实例023 利用if…else语句判断分数是否及格 34 实例024 利用switch语句判断时间 35 实例025 利用while...
  • 实例223 在TextBox控件中显示回车 实例224 只允许输入数字的TextBox控件 实例225 在TextBox控件底端显示下划线 实例226 屏蔽TextBox控件上的粘贴功能 实例227 屏蔽TextBox控件上默认的右键菜单 11.3 ...
  • 实例223 在TextBox控件中显示回车 实例224 只允许输入数字的TextBox控件 实例225 在TextBox控件底端显示下划线 实例226 屏蔽TextBox控件上的粘贴功能 实例227 屏蔽TextBox控件上默认的右键菜单 11.3 ...
  • 实例223 在TextBox控件中显示回车 实例224 只允许输入数字的TextBox控件 实例225 在TextBox控件底端显示下划线 实例226 屏蔽TextBox控件上的粘贴功能 实例227 屏蔽TextBox控件上默认的右键菜单 11.3 ...
  • SuperNotepad

    2012-11-14 11:23:53
    先选中要整体右移的文字段[Ctrl+J]或右键菜单中选[自定义替换],在对话框中输入[\par,\par\tab\tab],不包括左右[]括号(工具栏中有此功能) 2.如何查看文字的颜色、字体、编码?选中文本,在状态栏中查看 3.计算...
  •  实例142 身份证号从15升到18的算法 186  实例143 歌德巴赫猜想的算法实现 187  实例144 八皇后问题的算法实现 188  实例145 百钱百鸡的算法实现 190  实例146 韩信点兵的算法实现 191  实例147 实现...
  • 实例223 在TextBox控件中显示回车 297 实例224 只允许输入数字的TextBox控件 298 实例225 在TextBox控件底端显示下划线 299 实例226 屏蔽TextBox控件上的粘贴功能 300 实例227 屏蔽TextBox控件上默认的右键菜单 ...
  • 2.6.5 按位运算符 2.7 了解存储时间和作用域 2.7.1 自动变量 2.7.2 决定变量声明的位置 2.7.3 全局娈量 2.7.4 静态变量 2.8 命名空间 2.8.1 声明命名空间 2.8.2 多个命名空间 2.9 C++/CLI编程 2.9.1 C++/CLI特有的...
  • 2.6.5 按位运算符 2.7 了解存储时间和作用域 2.7.1 自动变量 2.7.2 决定变量声明的位置 2.7.3 全局娈量 2.7.4 静态变量 2.8 命名空间 2.8.1 声明命名空间 2.8.2 多个命名空间 2.9 C++/CLI编程 2.9.1 C++/CLI特有的...
  • 2.6.5 按位运算符 2.7 了解存储时间和作用域 2.7.1 自动变量 2.7.2 决定变量声明的位置 2.7.3 全局娈量 2.7.4 静态变量 2.8 命名空间 2.8.1 声明命名空间 2.8.2 多个命名空间 2.9 C++/CLI编程 2.9.1 C++/CLI特有的...
  • 2.6.5 按位运算符 2.7 了解存储时间和作用域 2.7.1 自动变量 2.7.2 决定变量声明的位置 2.7.3 全局娈量 2.7.4 静态变量 2.8 命名空间 2.8.1 声明命名空间 2.8.2 多个命名空间 2.9 C++/CLI编程 2.9.1 C++/CLI特有的...

空空如也

空空如也

1 2 3 4 5
收藏数 85
精华内容 34
关键字:

计算器按位计算符