用C#做的一个计算器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

/************************************************/
/*******         本程序供学习交流         *******/
/*******         作者:  张骏南            *******/
/*******         最后修改时间             *******/
/*******       2011年3月10日21:03:17      *******/
/************************************************/

namespace 计算器
{
    /// <summary>
    /// Window1.xaml 的交互逻辑
    /// </summary>
    public partial class Window1 : Window
    {
        private decimal m_dInput = 0;
        private int m_iPlaces = 0;          //数的小数位
        private bool m_bIsFloat = false;    //标记是否为小数
        private bool m_bNewInt = false;     //标记是否需要新的整数数
        private bool m_bNewFloat = false;   //标记是否需要新的浮点数
        private Counter m_ctrCounter = new Counter();
        private AboutBox1 m_abtAboutBox;

        public Window1()
        {
            InitializeComponent();
            updateInput();
        }

        //输入更新结果显示框
        private void updateInput()
        {
            //去除末尾多于的0
            if (m_bIsFloat)
                while (m_dInput.ToString().LastIndexOf('0') == m_dInput.ToString().Length - 1 && m_dInput != 0)
                    m_dInput = Convert.ToDecimal(m_dInput.ToString().Substring(0, m_dInput.ToString().Length - 1));

            //在结果加上适当的小数点
            if (m_dInput.ToString().Contains("."))
                result.Text = m_dInput.ToString();
            else
                result.Text = m_dInput.ToString() + ".";
        }

        #region 数字单击事件

        private void number_Click(object sender, RoutedEventArgs e)
        {
            newNumber();
            //确定是哪个数字被点击
            int inputNumber = Convert.ToInt32(sender.ToString().Substring(32, 1));
            try
            {
                if (m_dInput >= 0)
                {
                    if (m_bIsFloat)
                        m_dInput += (decimal)Math.Pow(10, -++m_iPlaces) * inputNumber;    //求 inputNumber 乘 10 的 -N 次方
                    else
                        m_dInput = m_dInput * 10 + inputNumber;
                }
                else
                {
                    if (m_bIsFloat)
                        m_dInput -= (decimal)Math.Pow(10, -++m_iPlaces) * inputNumber;    //求 inputNumber 乘 10 的 -N 次方
                    else
                        m_dInput = m_dInput * 10 - inputNumber;
                }
            }
            catch (OverflowException)
            {
                MessageBox.Show("输入的数超过范围，请重新输入", "错误");
                buttonCE_Click(sender, e);
            }
            updateInput();
        }

        //数字0的处理与其他不同
        private void number0_Click(object sender, RoutedEventArgs e)
        {
            if (m_bNewInt)
            {
                m_dInput = 0;
                m_iPlaces = 0;
                if (m_bNewFloat)
                {
                    m_bIsFloat = true;
                    m_bNewFloat = false;
                    result.Text = "0.";
                }
                else
                    m_bIsFloat = false;
                m_bNewInt = false;
            }
            try
            {
                if (m_bIsFloat)
                {
                    ++m_iPlaces;
                    result.Text += "0";
                }
                else
                {
                    m_dInput *= 10;
                    updateInput();
                }
            }
            catch (OverflowException)
            {
                MessageBox.Show("输入的数超过范围，请重新输入", "错误");
                buttonCE_Click(sender, e);
            }
        }

        #endregion

        //即将输入新的数
        private void newNumber()
        {
            if (m_bNewInt)
            {
                m_dInput = 0;
                m_iPlaces = 0;
                if (m_bNewFloat)
                    m_bNewFloat = false;
                else
                    m_bIsFloat = false;
                m_bNewInt = false;
            }
        }

        #region 操作按钮的单击事件

        //清空按钮被单击，清空当前输入数据
        private void buttonCE_Click(object sender, RoutedEventArgs e)
        {
            m_bIsFloat = false;
            m_bNewFloat = false;
            m_bNewInt = false;
            m_dInput = 0;
            m_iPlaces = 0;
            updateInput();
        }

        //退位操作
        private void buttonBackspace_Click(object sender, RoutedEventArgs e)
        {
            //不需要新的数
            m_bNewInt = false;

            //判断是否为小数并退一位
            if (m_bIsFloat)
                --m_iPlaces;

            if (m_dInput.ToString().Length == 1)
            {
                if (m_bIsFloat)
                {
                    if (m_iPlaces == -1)
                    {
                        m_bIsFloat = false;
                        m_iPlaces = 0;
                    }
                    else
                    {
                        result.Text = result.Text.Substring(0, result.Text.Length - 1);
                        m_dInput = Convert.ToDecimal(result.Text);
                        return;     //结束方法
                    }
                }
                else
                    m_dInput = 0;
            }
            else
            {
                if (m_bIsFloat)
                {
                    if (m_iPlaces == -1)
                    {
                        m_bIsFloat = false;
                        m_iPlaces = 0;
                    }
                    else
                    {
                        result.Text = result.Text.Substring(0, result.Text.Length - 1);
                        m_dInput = Convert.ToDecimal(result.Text);
                        return;
                    }
                }
                else
                    m_dInput = Convert.ToDecimal(m_dInput.ToString().Substring(0, m_dInput.ToString().Length - 1));
            }
            updateInput();
        }

        //负号按钮被单击事件
        private void minus_Click(object sender, RoutedEventArgs e)
        {
            m_dInput = -m_dInput;
            updateInput();
        }

        //小数点按钮被单击事件
        private void dot_Click(object sender, RoutedEventArgs e)
        {
            if (m_bNewInt)
                m_bNewFloat = true;
            m_bIsFloat = true;
        }

        //重启按钮被单击事件，计算器重启
        private void buttonC_Click(object sender, RoutedEventArgs e)
        {
            m_ctrCounter.Clear();
            buttonCE_Click(sender, e);
        }

        //开方按钮被单击事件
        private void operatorSqrt_Click(object sender, RoutedEventArgs e)
        {
            m_dInput = (decimal)Math.Sqrt((double)m_dInput);
            updateInput();
            m_bNewInt = true;
        }

        //除法按钮被单击事件
        private void operatorDivide_Click(object sender, RoutedEventArgs e)
        {
            m_dInput = m_ctrCounter.Calculate(m_dInput, Counter.Operators.Divide);
            updateInput();
            m_bNewInt = true;
        }

        //乘法按钮被单击事件
        private void operatorMultiply_Click(object sender, RoutedEventArgs e)
        {
            m_dInput = m_ctrCounter.Calculate(m_dInput, Counter.Operators.Multiply);
            updateInput();
            m_bNewInt = true;
        }

        //减法按钮被单击事件
        private void operatorSubtract_Click(object sender, RoutedEventArgs e)
        {
            m_dInput = m_ctrCounter.Calculate(m_dInput, Counter.Operators.Subtract);
            updateInput();
            m_bNewInt = true;
        }

        //加法按钮被单击事件
        private void operatorAdd_Click(object sender, RoutedEventArgs e)
        {
            m_dInput = m_ctrCounter.Calculate(m_dInput, Counter.Operators.Add);
            updateInput();
            m_bNewInt = true;
        }

        //倒数按钮被单击事件
        private void operatorReciprocal_Click(object sender, RoutedEventArgs e)
        {
            if (m_dInput == 0)
            {
                MessageBox.Show("操作有误","错误");
                buttonC_Click(sender, e);
                return;
            }
            //是否为小数
            if (m_dInput.ToString().Contains('.'))
            {
                m_dInput = 1 / m_dInput;
                Counter.ChangeToInteger(ref m_dInput);
            }
            else
                m_dInput = 1 / m_dInput;
            updateInput();
            m_bNewInt = true;
        }

        //等号按钮被单击事件
        private void operatorAssign_Click(object sender, RoutedEventArgs e)
        {
            m_dInput = m_ctrCounter.Calculate(m_dInput, Counter.Operators.Assign);
            updateInput();
            m_bNewInt = true;    //需要新的数
        }

        #endregion

        //打开关于对话框
        private void openAboutBox(object sender, RoutedEventArgs e)
        {
            m_abtAboutBox = new AboutBox1();
            m_abtAboutBox.ShowDialog();
        }
    }
}

 

计算器类

Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;

/************************************************/
/*******         本程序供学习交流         *******/
/*******         作者:  张骏南            *******/
/*******         最后修改时间             *******/
/*******       2011年3月10日21:03:17      *******/
/************************************************/

namespace 计算器
{
    public class Counter
    {
        private decimal m_dCacheOfAdd = 0;          //缓存，存储被加数
        private decimal m_dCacheOfMultiply = 0;     //缓存，存储被乘数
        private decimal m_dResult = 0;              //显示结果
        private int m_iAddNumber = 0;               //加法次数
        private int m_iSubtractNumber = 0;          //减法次数
        private int m_iMultiplyNumber = 0;          //乘法次数
        private int m_iDivideNumber = 0;            //除法次数

        //操作符，分别是：加、减、乘、除、赋值
        public enum Operators : byte { Add, Subtract, Multiply, Divide, Assign };

        //将精度很高的小数修改为其对应相等的整数
        public static void ChangeToInteger(ref decimal value)
        {
            decimal floor = decimal.Floor(value);
            decimal ceiling = decimal.Ceiling(value);
            //差值小于10e-6则视为相等
            if (value - floor <= (decimal)10e-6)
                value = floor;
            if (ceiling - value <= (decimal)10e-6)
                value = ceiling;
        }

        #region 基本算法

        //加法运算
        private decimal operatorAdd(decimal input)
        {
            m_dCacheOfAdd += input;
            return m_dCacheOfAdd;
        }

        //乘法运算
        private decimal operatorMultiply(decimal input)
        {
            m_dCacheOfMultiply *= input;
            ChangeToInteger(ref m_dCacheOfMultiply);
            return m_dCacheOfMultiply;
        }

        #endregion

        #region 传入五种新运算符调用的方法

        //新运算符为加法，在此方法中判断并调用之前操作符的对应运算，并在此方法中更新结果
        private void add(decimal input)
        {
            //存储中间计算值
            decimal result = 0;
            //判断之前是否有乘号
            if (m_iMultiplyNumber > 0)
            {
                result += operatorMultiply(input);
                input = 0;      // input 被使用后，不能再被使用，这里很重要！
                --m_iMultiplyNumber;
            }
            //判断之前是否有除号
            if (m_iDivideNumber > 0)
            {
                result += operatorMultiply(1 / input);
                input = 0;
                --m_iDivideNumber;
            }
            //判断之前是否有加号
            if (++m_iAddNumber == 2)
            {
                result += operatorAdd(input);
                --m_iAddNumber;
            }
            else
            {
                //判断之前是否有减号
                if (m_iSubtractNumber > 0)
                {
                    result = operatorAdd(-input - result);
                    --m_iSubtractNumber;
                }
                else
                    result = operatorAdd(input + result);
            }
            m_dResult = result;
        }

        //新运算符为减法，在此方法中判断并调用之前操作符的对应运算，并在此方法中更新结果
        private void subtract(decimal input)
        {
            //存储中间计算值
            decimal result = 0;
            //判断之前是否有乘号
            if (m_iMultiplyNumber > 0)
            {
                result += operatorMultiply(input);
                input = 0;      // input 被使用后，不能再被使用，这里很重要！
                --m_iMultiplyNumber;
            }
            //判断之前是否有除号
            if (m_iDivideNumber > 0)
            {
                result += operatorMultiply(1 / input);
                input = 0;
                --m_iDivideNumber;
            }
            //判断之前是否有减号
            if (++m_iSubtractNumber == 2)
            {
                result = operatorAdd(-input - result);
                --m_iSubtractNumber;
            }
            else
            {
                //判断之前是否有加号
                if (m_iAddNumber > 0)
                {
                    result += operatorAdd(input);
                    --m_iAddNumber;
                }
                else
                {
                    result = operatorAdd(input + result);
                }
            }
            m_dResult = result;
        }

        //新运算符为乘法，在此方法中判断并调用之前操作符的对应运算，并在此方法中更新结果
        private decimal multiply(decimal input)
        {
            //判断之前是否有乘号
            if (++m_iMultiplyNumber == 2)
            {
                operatorMultiply(input);
                --m_iMultiplyNumber;
            }
            else
            {
                //判断之前是否有除号
                if (m_iDivideNumber > 0)
                {
                    operatorMultiply(1 / input);
                    --m_iDivideNumber;
                }
                else
                    m_dCacheOfMultiply = input;
            }
            m_dResult = m_dCacheOfMultiply;
            return m_dCacheOfMultiply;
        }

        //新运算符为除法，在此方法中判断并调用之前操作符的对应运算，并在此方法中更新结果
        private decimal divide(decimal input)
        {
            //判断之前是否有除号
            if (++m_iDivideNumber == 2)
            {
                operatorMultiply(1 / input);
                --m_iDivideNumber;
            }
            else
            {
                //判断之前是否有乘号
                if (m_iMultiplyNumber >0)
                {
                    operatorMultiply(input);
                    --m_iMultiplyNumber;
                }
                else
                    m_dCacheOfMultiply = input;
            }
            m_dResult = m_dCacheOfMultiply;
            return m_dCacheOfMultiply;
        }

        //等号运算
        private void assign(decimal input)
        {
            //存储中间计算值
            decimal result = 0;
            //标记是否只有等号
            bool flag = false;
            //判断之前是否有乘号
            if (m_iMultiplyNumber > 0)
            {
                result += operatorMultiply(input);
                input = 0;      // input 被使用后，不能再被使用，这里很重要！
                --m_iMultiplyNumber;
                flag = true;
            }
            //判断之前是否有除号
            if (m_iDivideNumber > 0)
            {
                result += operatorMultiply(1 / input);
                input = 0;
                --m_iDivideNumber;
                flag = true;
            }
            //判断之前是否有减号
            if (m_iSubtractNumber > 0)
            {
                result = operatorAdd(-input - result);
                --m_iSubtractNumber;
                flag = true;
            }
            //判断之前是否有加号
            if (m_iAddNumber > 0)
            {
                result += operatorAdd(input);
                --m_iAddNumber;
                flag = true;
            }
            if (flag)
                m_dResult = result;
            else
                m_dResult = input;

            //清空缓存
            m_dCacheOfAdd = 0;
            m_dCacheOfMultiply = 0;
        }

        #endregion

        //供外部调用，并返回计算值
        public decimal Calculate(decimal input, Operators oper)
        {
            try
            {
                //根据运算符执行相应方法
                switch (oper)
                {
                    case Operators.Add: add(input); break;
                    case Operators.Subtract: subtract(input); break;
                    case Operators.Multiply: multiply(input); break;
                    case Operators.Divide: divide(input); break;
                    case Operators.Assign: assign(input); break;
                }
            }
            catch (DivideByZeroException)
            {
                MessageBox.Show("操作有误", "错误");
                Clear();
            }

            return m_dResult;
        }

        //重启计算器
        public void Clear()
        {
            m_dCacheOfAdd = 0;
            m_dCacheOfMultiply = 0;
            m_dResult = 0;
            m_iAddNumber = 0;
            m_iSubtractNumber = 0;
            m_iMultiplyNumber = 0;
            m_iDivideNumber = 0;
        }
    }
}

 

主程序界面：

 

关于对话框：