一个非常酷的Js计算器（加减乘除，浮点，以及括号运算，四则混合运算）

最新推荐文章于 2021-01-29 10:59:29 发布
最新推荐文章于 2021-01-29 10:59:29 发布
阅读量7.2k 收藏 14
点赞数 4
分类专栏： javascript html 文章标签： 计算机 javascript 计算器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/johnny_Nicolas/article/details/51426908
版权 
github源代码链接 : https://github.com/johnnylei/calculate


<!DOCTYPE html>
<html>
    <head>
        <title>calculate</title>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <link type="text/css" href="calculate.css" rel="stylesheet">
        <script type="text/javascript" src="calculate.js"></script>
    </head>
    <body οnlοad="pageLoad()">
<!--        <p>1+(2*3)-(((2*3)*((1+2)/3)-3*6)-(3*6))+3</p>
        <p>1.1+(2.1*3)-(((2.2*3)*((1.1+2.2)/3.3)-3.4*6)-(3.5*6))+3.6</p>-->
        <div id="calculate">
            <input type="text" id="show" value = '0' readonly>
            <div id="keyboard">
                <table>
                    <tr>
                        <td class = "ACkeyButton">AC</td>
                        <td class="keyButton">+</td>
                        <td class="keyButton">-</td>
                        <td class="keyButton">*</td>
                    </tr>
                    <tr>
                        <td class="keyButton">1</td>
                        <td class="keyButton">2</td>
                        <td class="keyButton">3</td>
                        <td class="keyButton">/</td>
                    </tr>
                    <tr>
                        <td class="keyButton">4</td>
                        <td class="keyButton">5</td>
                        <td class="keyButton">6</td>
                        <td class="keyButton">(</td>
                    </tr>
                    <tr>
                        <td class="keyButton">7</td>
                        <td class="keyButton">8</td>
                        <td class="keyButton">9</td>
                        <td class="keyButton">)</td>
                    </tr>
                    <tr>
                        <td class="keyButton">0</td>
                        <td class="keyButton">.</td>
                        <td id="calculateResult">=</td>
                        <td id = "deleteNumber">del</td>
                    </tr>
                </table>
            </div>
        </div>
    </body>
</html>


/* 
 * 这是一个功能比较强大的计算机
 * 运算法 包括了 加减乘除以及括号
 * 整个过程是面向对象实现的
 */


/**
 * 这是一个计算机类
 * 在点击了"AC"之后，会触发clean(),把Input框里面的显示成0,另外把表达式this.express清空
 * 在点击了“del”之后，会触发deleteNumber（），把表达式的最后一位删除，并且显示在Input框里面
 * 在点击普通字符，既标签属性class=keyButton,就会触发showExpresson,会把你所输入的字符显示在input框里面，然后把表达式赋值this.expression += expression
 * 在点击“=”之后，就会调用calculateResult（）方法进行计算；计算大致分为6步
 * 1.验证是否有非法的运算符
 * 2.验证是否有非法的浮点
 * 3，验证括号使用是否正确
 * 4.去掉表达式中的括号
 * 5.去掉表达式中的乘法和除法
 * 6.现在的表达式里面只有加法和减法运算符，接下来，我们只要进行加减法运算既可以得到最后的答案了
 * @returns {Calculate}
 */
function Calculate() {
    this.showArea = document.getElementById("show");
    this.expression = '';
    this.clean = function() {
        this.showArea.value = '0';
        this.expression = '';
    };
    this.deleteNumber = function() {
        this.expression = this.expression.substring(0,this.expression.length-1);
        this.showArea.value = this.expression;
    };
    this.showExpression = function(expression) {
        this.expression += expression;
        this.showArea.value = this.expression;
    };
    /**
     * first step we should remove bracket
     * second step we should remove Multiplic and Division
     * the last step just remove plus and minus,and then result out
     * @returns {undefined}
     */
    this.calculateResult = function() {
//        this.expression = "1.1+(2.1*3)-(((2.2*3)*((1.1+2.2)/3.3)-3.4*6)-(3.5*6))+3.6";
        var wrongMessage = "this expression is invalid";
        if (!this.checkOperator(this.expression) || !this.checkFloat(this.expression)) {
            this.showArea.value = wrongMessage;
            this.expression = '';
            return ;
        }
        if(this.hasBracket(this.expression)) {
            if (!this.checkBracket(this.expression)) {
                this.showArea.value = wrongMessage;
                this.expression = '';
                return ;
            }
            this.expression = this.removeBracket(this.expression);
        }


        if (this.hasMultiplicOrDivision(this.expression)) {
            this.expression = this.removeMultiplicOrDivision(this.expression);
        }
        if(this.hasPlusOrMinus(this.expression)) {
            this.expression = this.plusOrMinus(this.expression);
        }
        this.showArea.value = this.expression;
        this.expression = '';
    };
    /**
     * 
     * @param {type} expression
     * @returns {undefined|Boolean}
     * 检查运算符是否合法,第一个字符是除“-”意外的运算符都是非法的，最后一个字符是运算符，也是非法的；
     * 检查是否含有不合法的多运算符 “**”，“*\/”,"*+"，"*-","+*","++","+\/"以及两以上的连续运算符都是不允许的
     * 在多运算符里面除了 “--”，“+-”都是不合法的多运算符
     */
    this.checkOperator = function(expression) {
        /**
         * (^[\+\*\/])|([\+\-\*\/]$) 匹配首字符或是最后一个字符是不是运算符
         * ([\+\-\*\/][\+\*\/]+) [+,*,-,/]搭配一个或是多个[+,*,/]
         * ([\*\/](\-)+) [*,/]搭配一个或是多个[-]
         * ([\+\-](\-){2,}) [+,-]搭配两个以上的[-]
         * @type RegExp
         */
      var reg = /(^[\+\*\/])|([\+\-\*\/]$)|([\+\-\*\/][\+\*\/]+)|([\*\/](\-)+)|([\+\-](\-){2,})/;  
      if(reg.test(expression)) {
          return false;
      }
      return true;
    };
    /**
     * 
     * @param {type} expression
     * @returns {undefined}
     * 检查“.”是否在正确位置，".+","+.","^.",".$","2.2.3.4.5","..","..."都是不允许的。
     */
    this.checkFloat = function (expression) {
        /**
         * (^\.)|(\.$) expression以.开头或结尾
         * ([\+\-\*\/]\.)|(\.[\+\-\*\/]) expression出现".+","+."等情况
         * ((\d+\.+){2,}\d*) expression出现"2.2.3.4.5","..","..."等情况
         */
        var reg = /(^\.)|(\.$)|([\+\-\*\/]\.)|(\.[\+\-\*\/])|((\d+\.+){2,}\d*)/;
        if (reg.test(expression)) {
            return false;
        }
        return true;
    };
    /**
     * 
     * @param {type} expression
     * @returns {@this;@call;removeBracket}
     * make sure the expression has bracket
     */
    this.hasBracket = function(expression) {
        var hasBraketReg = /(\(|\))/; //查看表达expression中是否有（）；
        if (hasBraketReg.test(expression)) {
            return true;
        }
        return false;
    };
    /**
     * 检查表达式中的输入的括号输入正确；
     * 1.括号必须与运算符号连接在一起 既“3（”，“（*3”，“3*）”，“）3”,".)",".(","(.",").",是不允许的
     * 2.左括号的数量必须等于右括号的数量
     * @param {type} expression
     * @returns {undefined}
     */
    this.checkBracket = function(expression) {
        var reg = /([\d\.]\()|(\)[\d\.])|(\([\+\-\*\/\.])|([\+\-\*\/\.]\))/;
        if (reg.test(expression)) {
            return false;
        }
        var leftBracket = 0, rightBracket = 0;
        for (var i = 0; i < expression.length; i++) {
            if (expression.charAt(i) === "(") {
                leftBracket++;
            } else if(expression.charAt(i) === ")") {
                rightBracket++;
            }
        }
        if (!(leftBracket === rightBracket)) {
            return false;
        }
        return true;
    };
    /**
     * 
     * @param {type} expression
     * remove bracket;
     * @returns {undefined}
     */
    this.removeBracket = function(expression) {
        var regMatch = /\([^\(\)]+\)/g; //这个正则表达式匹配最里面的一层括号，既(这里面是不能包含“（”或是“）”的)
        var childExpression = expression.match(regMatch);
        var mySign = "&mySign&"; //用一个特殊标记记录等会需要替换的位置
        var replaceExpression = expression.replace(regMatch,mySign);
        var subExpression = "";
        for(var i = 0; i < childExpression.length; i++) {
            subExpression = childExpression[i].substring(1,childExpression[i].length-1);
            if (this.hasMultiplicOrDivision(subExpression)) {
                subExpression = this.removeMultiplicOrDivision(subExpression);
            }
            if (this.hasPlusOrMinus(subExpression)) {
                subExpression = this.plusOrMinus(subExpression);
            }
            replaceExpression = replaceExpression.replace(mySign,subExpression);
        }
        expression = replaceExpression;
        if(this.hasBracket(expression)) {
            expression = this.removeBracket(expression);
        } else {
            return expression;
        }
        return expression;
    };
    
    /**
     * 
     * @param {type} expression
     * @returns {@this;@call;removeMultiplicOrDivision}
     * make sure the expression with Multiplic Or Division
     */
    this.hasMultiplicOrDivision = function(expression) {
        var hasMultiplicOrDivisionReg =  /(\*|\/)/;
        if (hasMultiplicOrDivisionReg.test(expression)) {
            return true;
        };
        return false;
    };
    /**
     * 
     * @param {type} expression
     * remove Multiplic and Division
     * @returns {unresolved}
     */
    this.removeMultiplicOrDivision = function(expression) {
//        var expression = "1-13*2+3*456/3*15*8/5*4-50-40+32*2/16"; //test data
        var regMatch = /((\d+\.?\d*)(\*|\/))+(\d+\.?\d*)/g;
        var childResult = "";
        var childExpression = expression.match(regMatch);
        var mySign = "&mySign&"; //用一个特殊标记记录等会需要替换的位置
        var replaceExpression = expression.replace(regMatch,mySign);
        for(var i = 0; i < childExpression.length; i++) {
            childResult = this.multiplicOrDivision(childExpression[i]);
            replaceExpression = replaceExpression.replace(mySign,childResult);
        }
        expression = replaceExpression;
        return expression;
    };
    this.multiplicOrDivision = function(expression) {
        var regNumber = /\d+\.?\d*/g;
        var regOperator = /(\*|\/)/g;
        var arrNumbers = expression.match(regNumber);
        var arrOperators = expression.match(regOperator);
        
        var calResult = parseFloat(arrNumbers[0]);
        for (var i = 0; i < arrOperators.length; i++) {
            if (arrOperators[i] === '*') {
                calResult *= parseFloat(arrNumbers[i+1]);
            } else {
                calResult /= parseFloat(arrNumbers[i+1]);
            }
        }
        return calResult;
    };
    
    this.hasPlusOrMinus = function(expression) {
        var hasPlusOrMinusReg =  /(\+|\-)/;
        if (hasPlusOrMinusReg.test(expression)) {
            return true;
        };
        return false;
    };
    /**
     * 
     * @param {type} expression
     * this is the last step , just has plus or minus , after we done this step, the result out
     * @returns {Calculate.plusOrMinus.calResult}
     */
    this.plusOrMinus = function(expression) {
        /**
         *  如果第一个字符是“-”号,就在expression前面加上一个0即可
         */
        if (expression.charAt(0) === "-") {
            expression = 0 + expression;
        }
        var doubleMinusReg = /\-\-/;  //减去一个负数，等于加一个正数
        if (doubleMinusReg.test(expression)) {
            expression = expression.replace(doubleMinusReg,"+");
        }
        doubleMinusReg = /\+\-/;  //加上一负数，等于减去一个正数
        if (doubleMinusReg.test(expression)) {
            expression = expression.replace(doubleMinusReg,"-");
        }
        var regNumber = /\d+\.?\d*/g;
        var regOperator = /(\+|\-)/g;
        var arrNumbers = expression.match(regNumber);
        var arrOperators = expression.match(regOperator);
        
        var calResult = parseFloat(arrNumbers[0]);
        for (var i = 0; i < arrOperators.length; i++) {
            if (arrOperators[i] === '+') {
                calResult += parseFloat(arrNumbers[i+1]);
            } else {
                calResult -= parseFloat(arrNumbers[i+1]);
            }
        }
        return calResult;
    };
}


function pageLoad() {
    var calculate = new Calculate();
    var ACkeyButton = document.getElementsByClassName("ACkeyButton");
    ACkeyButton[0].onclick = function() { 
        calculate.clean();
    };
    var deleteNumber = document.getElementById("deleteNumber");
    deleteNumber.onclick = function() { 
        calculate.deleteNumber();
    };
    var calculateResult = document.getElementById("calculateResult");
    calculateResult.onclick = function () {
        calculate.calculateResult();
    };
    var keyButton = document.getElementsByClassName("keyButton");
    for (var i in keyButton) {
        /**
         *这个写法是错误的，因为i没有被lock住
         *在这个循环执行以后，点击keyButton的时候，i才获得具体的数值
         *因为点击的时候i才真正的获得数值
         */
//        keyButton[i].onclick = function() {
//            return calculate.showExpression(keyButton[i].innerHTML);
//        };
        //(function () { /* code */ } ()); // 推荐使用这个
        //(function () { /* code */ })(); // 但是这个也是可以用的
        /**
         * 下面两种写法都是可以的,因为它在自执行函数表达式闭包的内部
         * 因为闭包直接可以引用传入的这些参数，利用这些被lock住的传入参数，自执行函数表达式可以有效地保存状态。
         * i的值作为locked的索引存在，尽管循环执行以后，i的值变成了最后一个keybutton
         * 但闭包内部的lockedInIndex值是没有改变，因为他已经执行完毕了
         * 所以当点击连接的时候，结果是正确的
         */
        
//        (function(i){
//            keyButton[i].onclick = function() {
//            return calculate.showExpression(keyButton[i].innerHTML);
//            };
//        }(i));
        /**
         * 你也可以像下面这样应用，在处理函数那里使用自执行函数表达式
         * 但是相对来说，上面的代码更具可读性
         */
        keyButton[i].onclick = (function(index) {
            return function() {
                calculate.showExpression(keyButton[index].innerHTML);
            };
        })(i);
    }
};



#calculate {
    width: 300px;
    height: 320px;
    border: 1px #32CD32 solid ;
    border-radius: 5px;
    background-color: #00CCFF;
}
input {
    width: 97%;
    border-radius: 7px;
    background-color: #40e0d0;
    height: 8%;
    align-content: center;
    margin: 4px;
    text-align: right;
    font-size: 20px;
}
#keyboard {
   width: 100%;
    border-radius: 5px;
    height: 85%;
}
table {
    width: 100%;
    height: 100%;
}
tr td {
    width: 25%;
    height: 20%;
    background-color: #33CCFF;
    border: 1px solid;
    border-radius: 7px;
    text-align: center;
}
tr td:hover {
    background-color: #3366FF;
    cursor: pointer;
}
tr td:visited {
    background-color: #333399;
}


johnny_Nicolas
关注
  • 4
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
js实现四则运算通过逆波兰表达式
wcqwert的博客
11-20 339
var symbol = ['#', '(', '+', '-', '*', '/', ')'] var symbolPriority = { '#': 0, '(': 1, '+': 2, '-': 2, '*': 3, '/': 3, ')': 4 } // 如果遇到左括号则直接入栈 // 如果遇到右括号,则弹出站内只到出现左括号为止 /...
【JavaScript】运算符及其优先级
早睡早起长头发的博客
11-08 2568
运算符可以快速地对变量的值进行递增和递减操作，它属于一元运算符，只对一个表达式进行操作。（一元运算符）：参与运算的对象只有一个，并运算符必须出现在运算对象的左边。用来对数据进行二进制运算，将参与运算的操作数视为由二进制（0和1）组成的32位的串。赋值运算符用于将运算符右边的值赋给左边的变量，常用的赋值运算符及示例见下表。在实际开发中，逻辑运算符经常用于多个条件的判断，常用的逻辑运算符见下表。单目运算符，若a为false，结果为true，否则相反。a和b都为true，结果为true，否则为false。
带括号的四则运算表达式js实现
04-29
输入一个字符串形式的四则运算表达式，如"1.0+2.1*(3+4)" 直接谈出结果，输入在文件底部，自己写的。思路是先把中缀表达式转成后缀表达式，然后根据后缀表达式建立一个栈求出结果
JavaScript实现四则运算器程序
u011277123的博客
06-07 5848
零基础学编程by学哥 2017-06-06 09:13 上节课主要讲解的是一个注册页面，各种表单元素使用JavaScript来检查输入。 这节课来做一个比较好玩的加减乘除四则运算器程序。 程序设计思路 在第1章里面，曾经做过一个python程序的加减乘除四则运算器程序。 这节课来用JavaScript来实现一个同样的四则运算器程序。 页面加载之后，随机生成一道题目，2个数字和1
js加减乘除的简单运算
qq_42166078的博客
06-17 4782
js加减乘除的简单运算 一直忙于vue项目，很久没碰js的一些操作了，今天稍微有空看了看js代码当作复习，也供初学者学习。本人一直坚持的初衷将复杂逻辑简化，方便于学习，当然有不足之处，还请各位多多指教。如图所示，根据输入框输入的值进行简单的加减运算 代码如下 HTML <body> <h1>请输入两个参加运算的整数</h1> <div> <span>操作数1：</span> <input type="text
JavaScript 四则运算
fenfenguai的专栏
01-06 947
//除法函数 function accDiv(arg1,arg2){ var t1 = 0, t2 = 0, r1, r2, n; try { t1 = arg1.toString().split(".")[1].length; } catch(e) {t1 = 0;} try { t2 = arg2.toString().split(".")[1].length; } catch(e) {t2 =
易语言加减乘除简单计算器源码.rar
03-20
这个"易语言加减乘除简单计算器源码.rar"文件包含了使用易语言编写的计算器程序的源代码，对于学习易语言和理解基本的计算逻辑非常有帮助。 首先，易语言的核心特点是“易学易用”，它采用了汉字作为编程关键字，...
c#开发，unity环境，计算器，支持四则运算
05-09
在本文中，我们将深入探讨如何使用C#语言在Unity环境中开发一个支持四则运算、三角函数以及括号功能的计算器。Unity是一款强大的跨平台游戏引擎，而C#是其主要的编程语言，非常适合用于创建交互式3D应用，包括计算器...
我做的多则运算支持括号加减乘除
12-06
标题中的“我做的多则运算支持括号加减乘除”指的是一个计算器程序，它能够处理包含括号的数学表达式，并执行基本的四则运算（加法、减法、乘法和除法）。这个计算器是由Java编程语言实现的，显示了开发者在编程和...
c# 计算器（加减乘除）
10-25
下面我们将详细讨论如何实现这个“加减乘除”计算器。 首先，我们需要了解C#中的基本输入输出操作。在C#中，我们可以使用`Console.WriteLine`方法来打印信息到控制台，而`Console.ReadLine`则用于获取用户输入。在...
JS-Calculate:使用 JavaScript 创建一个简单的计算页面。 能够加、减、乘或除
06-06
JS计算赋值 2015 年 5 月 12 日 凯利·罗斯的任务。 截止日期为 5 月 13 日上午 8 点。
基于STC89C52单片机的简易计算器（不能实现先小数的加减乘除）
04-01
在本项目中，我们关注的是一个基于STC89C52单片机实现的简易计算器。这个计算器设计用于执行基本的数学运算，包括加法、减法、乘法和除法，但不支持带有小数的运算。下面将详细讨论相关知识点。 1. **STC89C52...
js实现简单计算器（四则运算）
热门推荐
一七得七
12-01 1万+
1.图样： 2.代码： js function validate(str){ var reg = /^\d+$/; if (!reg.test(str)) { alert("请输入数字"); } } function calculator(){ var pre=document.getElementById("p
看小伙如何用java一行核心代码实现四则混合运算(带括号)计算器
BatFor的博客
11-17 1815
哈哈，好了不开玩笑了，今天的主角就是java8的新特性Nashorn JavaScript(完全支持ECMAScript 5.1规范以及一些扩展)，简单来说，就是可用通过它实现，java和javascript代码的互相调用。当然，其实这个特性java8以前就有(Rhino)，只不过java8这个新的对以前进行了优化。 至于怎么用呢？让我们看下面这个例子。 我们都知道，javascript里面有个函...
Java中Double类型的精确计算
柒弦宇轩
12-23 1405
复制代码 import java.math.BigDecimal; public class DoubleUtil { private static final int DEF_DIV_SCALE = 5; // 小数点后的保留位数 /** * Double精确的加法运算 * @param d1 被加数 * @param d2 加...
js double类型加减乘除(防止精度损失)
天坑丶有米有的博客
07-27 9486
/** * 加法运算，避免数据相加小数点后产生多位数和计算精度损失。 * * @param num1加数1 | num2加数2 */ function numAdd(num1, num2) { var base...
html+js实现简单的网页计算器（支持四则运算带括号）
BalingHaku
11-14 4787
网络上的html+js计算器大多是两个数字加一个运算符，不能实现输入长算式，这恰好是我学习中的一个任务，我就对长算式计算进行了js语言的简单实现。 页面部分十分简单，因为我的任务主要是后端开发： <body> 输入算式：<input type="text" name="string" id="string" autocomplete="off"/> <input type="button" value="计算" id="" onclick="c
JS新手入门案例：用函数实现四则运算
雷狐大叔
01-29 2158
JS用函数实现四则运算 新手练习案例教程，有详细注释信息。 // itleihu var n1 = parseFloat(prompt('请输入第一个数字：')), arith = prompt('请输入运算符号（+、-、*、/):'), n2 = parseFloat(prompt('请输入第二数字：')); //利用parseFloat()内置函数将接收到值转换成浮点数字型，否则最后结果会是字符串拼接 function getAri(x, y, z) { //分别接收第一个数字（
js实现一个粗略的四则运算解释器
标子 的专栏
09-03 601
这样的一个解释器几乎没用，不过只是为了学习一下解释器的知识，有空继续学习。function Context(map) { this.map = map; }Context.prototype.getContext = function() { return this.map; }var context;function AbstractExpression() {} AbstractE
在C/C++开发一个计算器程序，实现加减乘除四则运算和括号和嵌套计算器，支
最新发布
05-24
持多位数输入和小数计算。可以使用栈来实现括号和嵌套计算器。 以下是一个简单的示例代码： ```c++ #include <iostream> #include <stack> #include <string> using namespace std; // 判断字符是否为数字 bool isDigit(char c) { return c >= '0' && c <= '9'; } // 将字符串转化为数字 double strToDouble(string str) { double res = 0.0; double base = 1.0; bool flag = false; // 是否有小数点 int i = 0; if (str[i] == '-') { flag = true; ++i; } for (; i < str.size(); ++i) { if (str[i] == '.') { flag = true; continue; } if (flag) { base *= 0.1; res += (str[i] - '0') * base; } else { res = res * 10 + (str[i] - '0'); } } return flag ? (flag && str[0] == '-' ? -res : res) : (flag && str[0] == '-' ? -res : res); } // 计算两个数的运算结果 double calculate(double a, double b, char op) { switch (op) { case '+': return a + b; case '-': return a - b; case '*': return a * b; case '/': return a / b; default: return 0; } } // 计算表达式的值 double evaluate(string expr) { stack<double> nums; stack<char> ops; for (int i = 0; i < expr.size(); ++i) { if (isDigit(expr[i])) { // 数字 int j = i; while (j < expr.size() && (isDigit(expr[j]) || expr[j] == '.')) { ++j; } double num = strToDouble(expr.substr(i, j - i)); nums.push(num); i = j - 1; } else if (expr[i] == '(') { // 左括号 ops.push(expr[i]); } else if (expr[i] == ')') { // 右括号 while (ops.top() != '(') { double b = nums.top(); nums.pop(); double a = nums.top(); nums.pop(); char op = ops.top(); ops.pop(); nums.push(calculate(a, b, op)); } ops.pop(); } else if (expr[i] == '+' || expr[i] == '-') { // 加减 while (!ops.empty() && ops.top() != '(') { double b = nums.top(); nums.pop(); double a = nums.top(); nums.pop(); char op = ops.top(); ops.pop(); nums.push(calculate(a, b, op)); } ops.push(expr[i]); } else if (expr[i] == '*' || expr[i] == '/') { // 乘除 while (!ops.empty() && (ops.top() == '*' || ops.top() == '/')) { double b = nums.top(); nums.pop(); double a = nums.top(); nums.pop(); char op = ops.top(); ops.pop(); nums.push(calculate(a, b, op)); } ops.push(expr[i]); } } while (!ops.empty()) { double b = nums.top(); nums.pop(); double a = nums.top(); nums.pop(); char op = ops.top(); ops.pop(); nums.push(calculate(a, b, op)); } return nums.top(); } int main() { string expr; cout << "请输入表达式：" << endl; cin >> expr; double res = evaluate(expr); cout << "计算结果为：" << res << endl; return 0; } ``` 这个程序支持多位数输入和小数计算，可以通过栈来实现括号和嵌套计算器。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值