精华内容
下载资源
问答
  • 普通计算器

    2013-03-18 19:47:14
    计算器,Java课程设计普通使用,基本功能全部实现
  • c代码-普通计算器

    2021-07-16 13:22:35
    c代码-普通计算器
  • 山寨版windows普通计算器,简单的加减乘除,正负数据,开根号,取百分比%,回删,1/x,和MC,MR,MS,M+,M-等,注释齐全无需动脑子就能看懂,大学生交交作业的好帮手
  • Java普通计算器

    2015-11-21 19:33:50
    一个可以具体使用的完整的图形化界面的Java计算器,代码实现也是很简单的,基本上新手用用很不错的
  • calculator:制作普通计算器
  • 这是一个依据月份间隔计算房租的APP,同时提供计算器的功能。仅提供试用,学习交流。计算结果提供参考,不能保证计算结果正确性。本人能力有限,如遇Bug请联系解决。适用于Android 8及以上版本。计算器界面计算结果...
  • 一个用C#编写的小程序,计算器~逻辑比较复杂~做的可能不是很好~但是能够运行
  • C# 简易的计算器,可以切换普通及科学模式进行运算,十分适合初学者。
  • Qt 简单的计算器 适合入门级的同志们~~
  • java普通计算器

    2011-10-09 18:55:17
    刚学会写的,希望多多指点!是用eclipse swt写的!压缩包里有源代码(从工程里单独取出来的)和工程还有导出的可运行的jar程序!
  • 栈的运用--普通计算器和逆波兰计算器 用栈实现计算器,这个比较难。有兴趣和热情的朋友,你可以看看。没有的,建议你看下一个数据结构。 逆波兰计算器是我们的终极目标,在实现目标之前,需要不断积累,所以我们...

    栈的运用--普通计算器和逆波兰计算器

     用栈实现计算器,这个比较难。有兴趣和热情的朋友,你可以看看。没有的,建议你看下一个数据结构。

    逆波兰计算器是我们的终极目标,在实现目标之前,需要不断积累,所以我们一步步来:

    普通单位加减乘除计算器-->普通多位加减乘除计算器-->前中后缀表达式规则-->逆波兰计算器

    单位加减乘除实现:输入一个字符串“2+2*5-2”,通过栈计算出答案

    算法原理:

    栈结构,我选取上面实现的链表模拟栈;在原有基础上,新增 isEmpty,getTop(获取栈顶),priority(获取操作符的优先级),isOper(判断是否为运算符),cal(输入两个数字与一个运算符进行数学运算)方法,具体实现见代码;

    创建numStick用于存储数字,创建operStick用于存储运算符,对字符串进行逐项扫描,每扫描一个字符判断其是否为运算符(+-*/)

    是运算符时,就判断operStick空吗(isEmpty实现)?空就直接入栈,不空就要进行当前运算符与栈顶运算符(用getTop获取)进行优先级的比较(priority实现)

    当前<=top,则将numStick中的两个栈点进行出栈,将operStick的栈顶进行出栈,这些出栈数据统统装入cal方法进行运算,运算结果放入numStick中,当前运算符入栈。当前>top,当前运算符直接入栈

    不是运算符时,就直接入numStick栈;在上述判断执行完后,继续循环执行,直到字符串中所有字符都被扫描即可;

    扫描完成后,所有数据被列入栈中,上述操作的目的旨在将高级运算在入栈时,运算干净,这样栈里都是同级的运算

    下面对栈中的同级运算数据进行运算,运算过程就是numStick出两个,operStick出一个,进入cal方法中运算,结果继续入numStick栈,然后接着重复计算,直到operStack中没有运算符残留,就结束。

    那么numStack中一定只剩下一个数字,而它就是我们苦苦寻找的结果!

    package cn.dataStructure.demo.stack.calculator;
    
    class DoubleNode{
        public int data;
        public DoubleNode next;//保存下一个结点
        public DoubleNode pre;//保存上一个结点
        public DoubleNode(int data){
            this.data =data;
        }
        @Override
        public String toString() {
            return "["+this.data +"]";
        }
    }
    class DoubleLinkedListStack{
        private DoubleNode root=new DoubleNode(0);//创建有头根节点
        public DoubleNode getRoot(){
            return this.root;
        }
        public void push(int data){//普通add:不按序号存储
            DoubleNode temp=this.root;//root不能动,需要辅助结点
            while (true){//查找链表最后结点
                if (temp.next==null){
                    break;
                }
                temp=temp.next;//向后一位
            }
            DoubleNode newNode=new DoubleNode(data);
            temp.next=newNode;//尾结点双向添加
            newNode.pre=temp;
        }
        public int pop(){
            if (root.next==null){//判断是否为空链表
                throw new RuntimeException("空栈");
            }
            DoubleNode temp=root;
            while (temp.next!=null){//遍历到链表最后
                temp=temp.next;
            }
            int value=temp.data;
            temp.pre.next=null;//自我删除
            return value;
        }
        public void show(){//逆向打印
            if (root.next==null){//判断是否为空链表
                System.out.println("空栈");
                return;
            }
            DoubleNode temp=root;
            while (temp.next!=null){//遍历到链表最后
                temp=temp.next;
            }
            while (temp!=root){//逆向打印
                System.out.println(temp);
                temp=temp.pre;
            }
        }
        //判断栈空
        public boolean isEmpty(){
            return root.next==null;
        }
        //返回栈顶的值
        public int getTop(){
            if (root.next==null){//判断是否为空链表
                throw new RuntimeException("空栈");
            }
            DoubleNode temp=root;
            while (temp.next!=null){//遍历到链表最后
                temp=temp.next;
            }
            return temp.data;
        }
        //返回运算符优先级,正比
        public int prioprity(int oper){
            if (oper=='*'||oper=='/'){
                return 1;
            }else if (oper=='+'||oper=='-'){
                return 0;
            }else {
                return -1;//暂且支持加减乘除
            }
        }
        //判断是否为加减乘除
        public boolean isOper(int oper){
            return oper=='+'||oper=='-'||oper=='/'||oper=='*';
        }
        //对数据进行计算
        public int cal(int num1,int num2,int oper){
            int result=0;//存储结果
            switch (oper){
                case '+':
                    result=num1+num2;
                    break;
                case '-'://栈先入后出,所以2-1
                    result=num2-num1;
                    break;
                case '*':
                    result=num1*num2;
                    break;
                case '/'://栈先入后出,所以2-1
                    result=num2/num1;
                    break;
            }
            return result;
        }
    }
    public class 栈实现计算器 {
        public static void main(String[] args) {
            DoubleLinkedListStack numStack=new DoubleLinkedListStack();//数字栈
            DoubleLinkedListStack operStack=new DoubleLinkedListStack();//运算符栈
            String str="2+5*2-2";//10
            int index=0;//对str进行扫描的索引
            char ch=' ';//保存每次扫描到的字符
            int num1;//存储要计算的数字
            int num2;
            int value;//用于承接临时计算数据
            //对字符串进行扫描,将所有数据录入栈中
            while (true){
                ch=str.substring(index,index+1).charAt(0);
                if (operStack.isOper(ch)){//判断是否为操作符
                    if (operStack.isEmpty()){//操作符栈空时,扫描到的操作符直接入栈
                        operStack.push(ch);
                    }else if (operStack.prioprity(ch)<=operStack.prioprity(operStack.getTop())){//判断当前操作符的优先级<=栈顶操作符的优先级
                        num1=numStack.pop();
                        num2=numStack.pop();
                        value=operStack.cal(num1,num2,operStack.pop());
                        numStack.push(value);
                        operStack.push(ch);
                    }else{//当前操作符的优先级>栈顶操作符的优先级
                        operStack.push(ch);
                    }
                }else {
                    numStack.push(ch-48);//数字是按char接收的,所以要减去48,从char恢复到int
                }
                index++;
                if (index==str.length()){//此时字符串中所有数据被扫描完
                    break;
                }
            }
            //对栈中数据进行计算
            while (true){
                if (operStack.isEmpty()){//当操作符栈空,数据计算完成
                    break;
                }
                num1=numStack.pop();
                num2=numStack.pop();
                value=operStack.cal(num1,num2,operStack.pop());
                numStack.push(value);
            }
            System.out.printf("%s=%d",str,numStack.pop());
        }
    }
    
    2+5*2-2=10

    开心了吗?其实还是有点不开心,因为上面这个只能是一位数字运算,多位数程序就崩了,原因在于我们在数字入栈前没有判断下一个字符是不是数字。那么我们开始着手升级

     多位加减乘除实现:输入一个字符串“2+2*5-20”,通过栈计算出答案

    算法分析:

    修改字符串

    String str="2+5*2-20";//-8

     新增number用于处理多位计算,将多次读入的字符合并

    String number="";//用于处理多位计算,将多次读入的字符合并

     对数字入栈进行升级

    //对字符串进行扫描,将所有数据录入栈中
            while (true){
                ch=str.substring(index,index+1).charAt(0);
                if (operStack.isOper(ch)){//判断是否为操作符
                    if (operStack.isEmpty()){//操作符栈空时,扫描到的操作符直接入栈
                        operStack.push(ch);
                    }else if (operStack.prioprity(ch)<=operStack.prioprity(operStack.getTop())){//判断当前操作符的优先级<=栈顶操作符的优先级
                        num1=numStack.pop();
                        num2=numStack.pop();
                        value=operStack.cal(num1,num2,operStack.pop());
                        numStack.push(value);
                        operStack.push(ch);
                    }else{//当前操作符的优先级>栈顶操作符的优先级
                        operStack.push(ch);
                    }
                }else {
                    //对下面这句话进行修改,实现多位运算支持
                    //numStack.push(ch-48);//数字是按char接收的,所以要减去48,从char恢复到int
                    number+=ch;//合并所有扫描到的数字
                    if (index==str.length()-1){//若该数字是最后一位,无需判断直接入栈
                        numStack.push(Integer.parseInt(number));
                    }else {//判断下一个字符是数字吗?不是则入栈
                        if (operStack.isOper(str.substring(index+1,index+2).charAt(0))){
                            numStack.push(Integer.parseInt(number));
                            number="";//清空number
                        }
                    }
                }

     效果如下

    2+5*2-20=-8

    上面的计算器实现最麻烦的是,要将人看的懂的表达式转化为机器能看懂的表达式!解决这个问题的办法----波兰表达式。

     

    前中后缀表达式规则

    前缀即波兰表达式,中缀即人看的表达式,后缀即逆波兰表达式,上面我们实现的计算机属于中缀计算器。其中逆波兰表达式,计算机最懂,所以我以逆波兰为主,制作一个逆波兰计算器

     

    逆波兰计算器实现

    算法分析:

    为了简化代码复杂度,使用系统提供的类集框架代替自己写的链表与栈

    将逆波兰表达式分割为一个个单独的字符串数组,通过逆波兰表达式阅读规则:遇到运算符就出栈两个数字,编写计算方法

    package cn.dataStructure.demo.stack.calculator;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Stack;
    
    public class 逆波兰计算器 {
        public static void main(String[] args) {
            String str="2 5 * 8 2 / + 1 -";//(2*5)+8/2-1-->2 5 * 8 2 / + 1 -;13
            List<String> list=getListString(str);
            System.out.printf("(2*5)+8/2-1=%d",calculate(list));
    
        }
        //分割逆波兰表达式入list存储
        public static List<String> getListString(String str){
            String split[]=str.split(" ");
            List <String> list=new ArrayList<>();
            for (String temp:split) {
                list.add(temp);
            }
            return list;
        }
        //逆波兰表达式计算
        public static int calculate(List<String> list){
            Stack<String> stack=new Stack<>();
            for (String temp:list){
                if (temp.matches("\\d+")){//正则匹配多位数字
                    stack.push(temp);
                }else {
                    int num1= Integer.parseInt(stack.pop());
                    int num2= Integer.parseInt(stack.pop());
                    int value=0;
                    switch (temp){
                        case "+":
                            value=num2+num1;
                            break;
                        case "-":
                            value=num2-num1;
                            break;
                        case "*":
                            value=num2*num1;
                            break;
                        case "/":
                            value=num2/num1;
                            break;
                        default:
                            throw new RuntimeException("运算符有误");
                    }
                    stack.push(""+value);//利用+将int转为string
                }
            }
            return Integer.parseInt(stack.pop());
        }
    }
    
    2*5+8/2-1=13

    你有没有一个疑问,有没有可以把中缀表达式自动转化为逆波兰表达式的算法?有,如下:

    中缀-->逆波兰

    举个例子:“1+((2+3)*4)-5”-->“1 2 3 + 4 * + 5 -”

    在整个过程中,s1不断进行入栈,出栈操作,所以s1一定为栈结构,但s2只有入栈,没有出栈,且若s2以栈结构时,最后输出逆波兰表达式时,需要逆向输出。所以我们使用ArrayList来代替栈结构。

    在上面的代码中我们已经实现了逆波兰表达式计算,下面实现中缀表达式转逆波兰。算法流程和上面图片中描述的一样

    算法分析:

    1,对getListString方法进行改造,使之可以对中缀表达式字符串进行分割,该算法支持多位整数。

    public static List<String> getListString(String str){
            List<String> list=new ArrayList();
            int index=0;//字符串索引标记
            char ch;//拆分的字符
            String string;//拼接的字符串
            do {
                ch=str.charAt(index);
                if (ch<48||ch>57){//非数字
                    list.add(""+ch);
                    index++;
                }else {//是数字,考虑多位问题
                    string="";
                    //index不能越界,且下一位仍然为数字
                    while (index<str.length()&&(ch=str.charAt(index))>=48&&(ch=str.charAt(index))<=57){
                        string+=ch;
                        index++;
                    }
                    list.add(string);
                }
            }while (index<str.length());
            return list;
        }

    2,新增parseSuffix方法,用于将拆分好的中缀表达式转化为逆波兰表达式。

    这里有个坑:进行字符串比较的时候要用equals方法,不要用==比较。这里牵扯到Java字符串底层机制(入池与不入池),详见我的Java SE博客:【String类-字符串比较】

    //中缀表达式转逆波兰表达式的方法
        public static List<String> parseSuffix(List<String> list){
            Stack<String> s1=new Stack<>();//s1用于存储运算符
            List<String > s2=new ArrayList();//s2用于存储结果
            for (String temp:list){
                if (temp.matches("\\d+")){//是数字,入s2栈
                    s2.add(temp);
                }else {//非数字(运算符,括号)
                    //是括号
                    if (temp.equals("(")){//(,直接入栈
                        s1.push(temp);
                    }else if (temp.equals(")")){//),不断s1弹出运算符入s2,直到遇到s1的(为至,并将这一对括号丢弃
                        while (!s1.peek().equals("(")){
                            s2.add(s1.pop());
                        }
                        s1.pop();//抛弃括号
                    }else if (s1.isEmpty()){//s1空,直接入栈
                        s1.push(temp);
                    }else if (s1.peek().equals("(")){//s1的栈顶为(,直接入栈
                        s1.push(temp);
                    }else if (getPriority(temp)>getPriority(s1.peek())){//当前运算符优先级>栈顶优先级,直接入栈
                        s1.push(temp);
                    }else {
                        while (s1.size()!=0&&getPriority(temp)<=getPriority(s1.peek())){
                            s2.add(s1.pop());
                        }
                        s1.push(temp);
                    }
                }
            }
            //将s1剩余字符串依次加入s2
            while (s1.size()!=0){
                s2.add(s1.pop());
            }
            return s2;
        }

    3,parseSuffix方法需要getPriority方法(获取操作符优先级)支持

    //获取优先级
        public static int getPriority(String oper){
            int value=0;
            switch (oper){
                case "+":
                    value=1;
                    break;
                case "-":
                    value=1;
                    break;
                case "*":
                    value=2;
                    break;
                case "/":
                    value=2;
                    break;
            }
            return value;
        }

    4,在主方法编辑测试代码

    String str="1+((2+3)*4)-5";//1 2 3 + 4 * + 5 -
            List<String> list=getListString(str);//拆分字符串
            List<String> suffix=parseSuffix(list);//获取逆波兰表达式
            System.out.println(str+"="+calculate(suffix));
    1+((2+3)*4)-5=16

     

    【数据结构与算法整理总结目录 :>】<-- 宝藏在此(doge)  

    展开全文
  • C#普通计算器与科学计算器

    千次阅读 2014-06-05 09:43:53
     1)基本功能:实现“普通运算”功能,支持连续运算,如连续输入“2+3×5”后点击“等号”按钮进行运算其结果为25.  2)附加功能: A,支持“科学运算”功能,即输入表达式时遵循运算符号的优先原则,连续输入“2...

    一. 功能

      1)基本功能:实现“普通运算”功能,支持连续运算,如连续输入“2+3×5”后点击“等号”按钮进行运算其结果为25.

      2)附加功能:

    A,支持“科学运算”功能,即输入表达式时遵循运算符号的优先原则,连续输入“2+3×5”后点击“等号”按钮进行运算其结果为17;

    B,支持数字键盘(小键盘)输入功能(焦点不在文本框内时也支持键盘输入);

    二. 设计思路

    在项目中设计一个计算类,其中包含“普通计算”和“科学计算”功能,即输入数学运算表达式字符串,返回计算结果。直接在项目中调用该类,输出计算结果。

    public partial class Form1 : Form
        {
            string str = string.Empty;
            string sumStr;
            char[] _operator = { '+', '-', '*', '/', '%' };
            string[] strArray;
            char[] opArray;
            Regex r = new Regex(@"[0-9]");
            public Form1()
            {
                InitializeComponent();
            }
    
            private void Press_Button_Click(object sender, EventArgs e)
            {
                if (textBox2.Text.Contains('='))
                {
                    textBox2.Text = "";
                    if (r.IsMatch((string)((Button)sender).Tag))//判D断?是?否?接ó着?计?算?
                    {
                        str = "";
                    }
    
                }
                if (!str.Contains('.'))
                {
                    str += (string)((Button)sender).Tag;
                    textBox1.Text = str;
                }
                else
                {
                    if ((string)((Button)sender).Tag != ".")
                    {
                        str += (string)((Button)sender).Tag;
                        textBox1.Text = str;
                    }
                }
            }
    
            private void Clear_Button_Click(object sender, EventArgs e)
            {
                textBox1.Text = textBox2.Text = "";
                str = "";
                textBox1.Text = 0.ToString();
            }
    
            private void Delete_Button_Click(object sender, EventArgs e)
            {
                if (str.Length > 0)
                {
                    str = str.Substring(0, str.Length - 1);
                    if (str.Length == 0)
                    {
                        textBox1.Text = "0";
                    }
                    else
                        textBox1.Text = str;
                }
            }
    
            private static string MyOperate(string strA, string strB, char _operator)
            {
                double numA = Convert.ToDouble(strA);
                double a, b, numB;
                double result = 0;
                if (strB.Contains('^'))
                {
                    a = Convert.ToDouble(strB.Split('^')[0]);
                    b = Convert.ToDouble(strB.Split('^')[1]);
                    numB = Math.Pow(a, b);
                }
                else if (strB.Contains('Ó'))
                {
                    numB = Math.Sqrt(Convert.ToDouble(strB.Substring(1)));
                }
                else
                {
                    numB = Convert.ToDouble(strB);
                }
                switch (_operator)
                {
                    case '+': result = numA + numB; break;
                    case '-': result = numA - numB; break;
                    case '*': result = numA * numB; break;
                    case '/':
                        {
                            if (numB == 0)
                            {
                                return "除y数簓不?能ü为a零?!?";
                            }
                            result = numA / numB;
                            break;
                        }
                    case '%':
                        {
                            if (numA.ToString().Contains('.') == true || numB.ToString().Contains('.'))
                            {
                                return "不?能ü对?浮?点?数簓求ó余?!?";
                            }
                            result = numA % numB;
                            break;
                        }
                }
                return result.ToString();
            }
    
    
            private void Equal_Button_Click(object sender, EventArgs e)
            {
                if (radioButton1.Checked)
                {
                    sumStr = MyNormalCalculating(str);
                }
                else
                {
                    sumStr = MyScienceCalculating(str);
                }
                if (strArray.Length == 1)
                {
                    textBox1.Text = sumStr;
                }
                else
                {
                    str += '=';
                    textBox2.Text = str;
                    textBox1.Text = sumStr;
                }
                str = sumStr;
            }
    
            private string MyScienceCalculating(string s)
            {
                strArray = str.Split(_operator);
                opArray = new char[strArray.Length - 1];
                int index = -1;
                int numLength = 0;
                int opLength = 0;
                for (int i = 0; i < strArray.Length - 1; i++)
                {
                    index += (strArray[i].Length + 1);
                    opArray[i] = str[index];
                }
                opLength = opArray.Length;
                numLength = strArray.Length;
                for (int i = 0; i < opLength; i++)
                {
                    if (opArray[i] == '*' || opArray[i] == '/')
                    {
    
                        strArray[i] = MyOperate(strArray[i], strArray[i + 1], opArray[i]);
    
                        for (int k = i + 1; k < numLength - 1; k++)
                        {
                            strArray[k] = strArray[k + 1];
                        }
                        numLength--;
                        for (int k = i; k < opLength - 1; k++)
                        {
                            opArray[k] = opArray[k + 1];
                        }
                        opLength--;
                    }
                }
                for (int i = 0; i < opLength; i++)
                {
                    strArray[i + 1] = MyOperate(strArray[i], strArray[i + 1], opArray[i]);
                }
                return strArray[numLength - 1];
            }
    
            private string MyNormalCalculating(string s)
            {
                strArray = str.Split(_operator);
                string sum = "0";
                char op;
                int index = -1;
                for (int i = 0; i < strArray.Length; i++)
                {
                    if (i == 0)
                    {
                        sum = MyOperate(sum, strArray[i], '+');
                    }
                    else
                    {
                        index += (strArray[i - 1].Length + 1);
                        op = s[index];
                        sum = MyOperate(sum, strArray[i], op);
                    }
                }
                return sum;
            }
    
            private void Form1_KeyPress(object sender, KeyPressEventArgs e)
            {
                switch (e.KeyChar)
                {
                    case '0': Press_Button_Click(button16, null); break;
                    case '1': Press_Button_Click(button5, null); break;
                    case '2': Press_Button_Click(button6, null); break;
                    case '3': Press_Button_Click(button7, null); break;
                    case '4': Press_Button_Click(button9, null); break;
                    case '5': Press_Button_Click(button10, null); break;
                    case '6': Press_Button_Click(button11, null); break;
                    case '7': Press_Button_Click(button13, null); break;
                    case '8': Press_Button_Click(button14, null); break;
                    case '9': Press_Button_Click(button15, null); break;
                    case '.': Press_Button_Click(button12, null); break;
                    case '+': Press_Button_Click(button17, null); break;
                    case '-': Press_Button_Click(button8, null); break;
                    case '*': Press_Button_Click(button4, null); break;
                    case '/': Press_Button_Click(button3, null); break;
                    case '^': Press_Button_Click(button23, null); break;
                    case 'Ó': Press_Button_Click(button22, null); break;
                    case (char)Keys.Enter:
                    case '=': Equal_Button_Click(Equal_Button, null); break;
                    case (char)Keys.Back: Delete_Button_Click(Delete_Button, null); break;
                }
            }
    
            private void radioButton1_CheckedChanged(object sender, EventArgs e)
            {
                str = string.Empty;
                textBox1.Text = "0";
                textBox2.Text = "";
            }
    
        }


    展开全文
  • 在Unity中搭建一个UI界面,添加必要的Button,用C#代码写的计算器的计算功能,可以实现加减乘除取余退格关闭等功能。
  • 普通计算器代码实现功能: 加减乘除运算功能 取小数 取相反数 清除一位数及运算符 全部清除 2。界面: 此界面参照oppo r9手机自带计算器的界面 3。思路 (1)显示: 显示界面实际为两个框,下方的是...

    1。普通计算器代码实现功能

    • 加减乘除运算功能
    • 取小数
    • 取相反数
    • 清除一位数及运算符
    • 全部清除

    2。界面
    这里写图片描述
    此界面参照oppo r9手机自带计算器的界面

    3。思路
    (1)显示:
    显示界面实际为两个框,下方的是showwin,上方的是calwin
    用js的字符串拼接将点击的值拼接起来存储在results中,lastkey存储当前鼠标点击的值,然后将results的值放入showwin中,显示出来
    (2)加减乘除运算:
    点击 = 后,显示运算的结果值,此时运用到js中的eval()函数,可计算某个字符串。
    (3)清除全部:
    这个功能很容易实现,只需都初始化就行
    (4)清除一位操作:
    本来我想的很复杂,但是后来想到了js强大的自身封装好的函数功能,可以直接使用substr()函数,此函数从字符串中抽取从 start 下标开始的指定数目的字符,清除一位的话就是最后一位不要了,所以我们就取0到字符串的长度-1的长度显示出来。
    (5)取负
    设置一个变量flag用来存储现在数的正负,初始为正,故flag为1。再设置一个变量results2来存储正值。每次都判断flag是1还是-1来进行不同的运算就可以了。

    4。注意事项
    (1)当点击的是”=”或是显示界面的空白处时,不返回任何值。因为此函数是点击就会在显示界面中显示点击值
    (2)当点击两次或多次运算位时,不返回任何值
    (3)一次运算结束之后,运算结果参与第二次运算。此时当点击的是运算符时,就会直接进行第二次的运算,进行字符串的拼接。
    (4)点击小数点时,当没有输入数据,会直接变成0.xx
    (5)如果数字前是乘除或后面是乘除然后点击了“=”,则显示输入错误

    5。存在的不足
    (1)lastkey的值还是有一些乱。
    (2)刚刚在写博客的时候发现,小数点这里的问题很多,比如点击了多次小数点,还有比如已经是1.23然后再点击“.”的时候会显示1.23.xx这样的。需要继续改进。
    6。需要掌握的知识
    js:
    - 正则表达式(初步了解即可)
    - event对象。(这个需要考虑一下兼容性问题)
    - obj.substr()
    - obj.match()
    - eval()
    css:
    border-spacing: 0;
    7。代码

    html及js

    <!DOCTYPE html>
    <html>
    <head>
        <meta  http-equiv="Content-Type" content="text/html" charset="utf-8"/>
        <link rel="stylesheet" type="text/css" href="css/index.css">
        <title>calculator</title>
    </head>
    <body>
        <table onclick="calculator()" id="calculator">
            <tr>
                <td colspan="4" id="calwin"> </td>
            </tr>
            <tr>
                <td colspan="4" id="showwin">0</td>
            </tr>
            <tr>
                <td class="numberbtn" id="deletebtn">C</td>
                <td class="numberbtn">+/-</td>
                <td class="numberbtn"><-]</td>
                <td class="operatebtn">/</td>
            </tr>
            <tr>
                <td class="numberbtn">7</td>
                <td class="numberbtn">8</td>
                <td class="numberbtn">9</td>
                <td class="operatebtn">*</td>
            </tr>
            <tr>
                <td class="numberbtn">4</td>
                <td class="numberbtn">5</td>
                <td class="numberbtn">6</td>
                <td class="operatebtn">-</td>
            </tr>
            <tr>
                <td class="numberbtn">1</td>
                <td class="numberbtn">2</td>
                <td class="numberbtn">3</td>
                <td class="operatebtn">+</td>
            </tr>
            <tr>
                <td class="numberbtn" colspan="2">0</td>
                <td class="numberbtn">.</td>
                <td class="operatebtn" onclick="resequal()">=</td>
            </tr>
        </table>
        <script type="text/javascript" src="js/jquery.min.js"></script>
        <script type="text/javascript">
            var calresults="";//运算结果
            var results="";//运算表达式
            var results2="";//存储正值
            var lastkey="";//存储点击值
            var flag=1;//正负号变换标志
            //正则表达式
            var re1=/^[\*|\/].+/;//操作数前面是乘或除
            var re2=/.+[\*|\/]$/;//操作数最后面是乘或除
            var re3=/(\+|-|\*|\/)/;//加减乘除
            function calculator(){
                //如果点击的是=或者是上面显示框的空白处,就不返回
                if (event.srcElement.innerText=="="||event.srcElement.id=="showwin"||event.srcElement.id=="calwin") {
                    return;
                }
                //清除全部功能
                else if (event.srcElement.innerText=="C") {
                    results="";
                    calresults="";
                    showwin.innerText="0";
                    calwin.innerText="";
                    return;
                }
                //清除一位
                else if(event.srcElement.innerText=="<-]") {
                    results=results.substr(0,results.length-1);
                    showwin.innerText = results;
                    return;
                }
                //点击两次运算位
                else if (lastkey.match(re3)&&event.srcElement.innerText.match(re3)) {
                    return;
                }
                //取负
                else if (event.srcElement.innerText=="+/-"&&results!="") {
                    if (flag==-1) {
                        //强制转换为字母类型
                        results=String(results2);
                        showwin.innerText=results;
                        flag=-flag;
                        return;
                    }
                    results2=results;
                    results="-"+results;
                    flag=-flag;
                    showwin.innerText=results;
                    return;
                }
                //取上次运算结果继续运算
                else if (lastkey=="="&&event.srcElement.innerText.match(re3)) {
                    results=calresults;
                    results+=event.srcElement.innerText;
                    showwin.innerText=results;
    
                }
                //如果没有输入数据点击小数点时
                else if (event.srcElement.innerText=="."&&results=="") {
                    results="0"+event.srcElement.innerText;
                    showwin.innerText=results;
                }
                else{
                    results+=event.srcElement.innerText;
                    lastkey=event.srcElement.innerText;
                    showwin.innerText=results;
                }
    
            }
            function resequal(){
                //如果数字前是乘除或数字后是乘除
                if (results.match(re1)||results.match(re2)) {
                    showwin.innerText="输入错误!";
                    calwin.innerText="";
                    results="";
                    return;
                }
                else{
                    calresults=eval(results);
                    showwin.innerText=calresults;
                    calwin.innerText=results;
                    lastkey="=";
                }
            }
    
        </script>
    
    </body>
    </html>

    css:

    *{
        padding:0;
        margin:1px;
    }
    #calculator{
        margin: auto;
        margin-top: 50px;
        border-spacing: 0;
    }
    #calwin{
        width: 100%;
        max-width: 246px;
        height: 60px;
        background-color:rgb(23,24,32);
        font-weight: bold;
        color: #ddd; 
        text-align: right;
        padding-right: 5px;
    }
    #showwin{
        width: 100%;
        max-width: 246px;
        height: 30px;
        background-color: rgb(23,24,32);
        color: rgb(220,220,221);
        font-weight: bold;
        overflow: hidden;
        text-align: right;
        padding-right: 5px;
    }
    .numberbtn{
        cursor:pointer;
        width: 60px;
        height: 60px;
        text-align: center;
        border: 0.5px solid rgb(54,54,58);
        background-color: rgb(55,59,74);
        color: #fff;
    }
    .numberbtn:hover,.numberbtn:active{
        background-color: rgb(39,40,47);
    }
    .operatebtn{
        cursor: pointer;
        width: 60px;
        height: 60px;
        text-align: center;
        border: 0.5px solid rgb(54,54,58);
        background-color: rgb(166,61,70);
        color: #fff;
    }
    .operatebtn:hover,.operatebtn:active{
        background-color: rgb(146,53,61);
    }
    展开全文
  • 普通计算器在线使用

    2010-04-01 22:43:00
    收藏---ab126计算公式大全 普通计算器在线使用

    收藏---ab126计算公式大全  普通计算器在线使用

    展开全文
  • 仿照windows普通计算器功能编写的计算器源码,用VC6.0对话框编的,完全按windows普通计算器得功能处理特殊或者错误输入
  • MFC 计算器 VC++ 我自己写的有缺陷.请大家包含。内包含源代码
  • 计算器的实现有关科学计算器的方法设计(C#)有关普通计算器和科学计算器的代码如下画图功能的实现如下 有关普通计算器和科学计算器的代码如下 using System; using System.Collections.Generic; using System....
  • 在数据中心记录计算过程,本地... Calculator类:计算器主类,其中包括添加各组件,添加监听等操作。  GC类:显示计算过程的面板类。  Number_Key类:计算器的各个按钮组件类。  Result类:显示计算结果的面板类。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,445
精华内容 8,178
关键字:

下载普通计算器