C#窗体——四则运算

用户需求：
程序能接收用户输入的整数答案，并判断对错
程序结束时，统计出答对、答错的题目数量。
补充说明：0——10的整数是随机生成的
用户可以选择四则运算中的一种
用户可以结束程序的运行，并显示统计结果。
在此基础上，做增量开发。

增量内容：

             （1）处理用户的错误输入，比如输入字母或符号等，处理除法运算中分母为0的情况，处理结果为负数的情况，保证是小学水平不出现负数，比如不能出现5-8=-3这种情况；
             （2）用户可以设定倒计时；
             （3）用户可以设定随机整数的范围和题目数量；
             （4）用户可以选择哪种计算类型，比如加减乘除，或可选择软件随机生成四则运算中的一种；
             （5）用户可以选择随机生成的题目中是否带有小括号，比如（2+3）*5，如果是gui程序，添加这个功能可以用复选框实现。
             （6）保证生成过的题目不再重复出现。

设计思路：

              我的想法是，先生成两个数运算的表达式，就和上次的一样。先让两个数进行加减计算，得到一个结果，之后再与第三个数进行乘除运算。如果要是这样做的话就要让它产生两个运算符，那就会有先算乘除后算加减了。就不能达到（2+3）*5这种先加减后乘除的运算了。并且也不能一次就生成一个三个数运算的表达式。所以就把这种想法舍弃了。
             因此呢，我们就把第一个和第二个文本框合并成了一个文本框，让它来存一个运算表达式。不管是生成两个数亦或是三个数的表达式都可以，最后只需要对这个字符串表达式进行计算就可以了。这才只是生成一个式子。难点在于对这个式子进行计算，要把这个式子取出来，用到队列，把它的每一个字符都取出来放到了栈里之后再进行计算。

代码实现：

Form1.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace _Random
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        public static int select = 0;
        public static int Count = 0;
        private int t = 60;
        public static int right = 0;

        private void button1_Click(object sender, EventArgs e)
        {
            label2.Text = t.ToString();
            timer1.Enabled = true;
            timer1.Interval = 1000;
            timer1.Start();
        }

        private void RDN()
        {
            Random ran=new Random();
            int n1,n2;
            if (textBox4.Text==""&&textBox5.Text=="")
            {
                MessageBox.Show("请输入取值范围!");
                return;
            }
            if (checkBox1.Checked == true)
                select = 1;
            for (int i = 0; i < int.Parse(textBox6.Text); i++)
            {
                textBox1.Clear();
                switch (select)
                {
                    case 1:
                        {
                            n1 = ran.Next(int.Parse(textBox4.Text), int.Parse(textBox5.Text));
                            n2 = ran.Next(int.Parse(textBox4.Text), int.Parse(textBox5.Text));
                            int n3 = ran.Next(1, int.Parse(textBox5.Text));
                            textBox1.Text += "(";
                            if (n1 < 0) textBox1.Text += "(" + n1 + "）";
                            else textBox1.Text += n1;
                            if (ran.Next(0, 2) == 1) textBox1.Text += "+";
                            else textBox1.Text += "-";
                            if (n2 < 0) textBox1.Text += "(" + n2 + ")";
                            else textBox1.Text += n2 + ")";
                            if (ran.Next(0, 2) == 1) textBox1.Text += "*"+n3;
                            else textBox1.Text += "/" + n3;
                            break;
                        }
                }
                
                textBox3.Text = "";
            }                
        }

        private void RandomNumjia()
        {
            textBox1.Clear();
            textBox3.Clear();
            if (textBox4.Text == "" && textBox5.Text == "")
            {
                MessageBox.Show("请输入取值范围!");
                return;
            }

            Random ran = new Random();
            int n1 = ran.Next(int.Parse(textBox4.Text), int.Parse(textBox5.Text));
            int n2 = ran.Next(int.Parse(textBox4.Text), int.Parse(textBox5.Text));
            if (n1 < 0) textBox1.Text += "(" + n1 + ")";
            else textBox1.Text += n1;
            textBox1.Text += "+";
            if (n2 < 0) textBox1.Text += "(" + n2 + ")";
            else textBox1.Text += n2; 
        }

        private void RandomNumjian()
        {
            textBox1.Clear();
            textBox3.Clear();
            if (textBox4.Text == "" && textBox5.Text == "")
            {
                MessageBox.Show("请输入取值范围!");
                return;
            }

            Random ran = new Random();
            int n1 = ran.Next(int.Parse(textBox4.Text), int.Parse(textBox5.Text));
            int n2 = ran.Next(int.Parse(textBox4.Text), int.Parse(textBox5.Text));
            if (n1 < 0) textBox1.Text += "(" + n1 + ")";
            else textBox1.Text += n1;
            textBox1.Text += "-";
            if (n2 < 0) textBox1.Text += "(" + n2 + ")";
            else textBox1.Text += n2;
        }

        private void RandomNumcheng()
        {
            textBox1.Clear();
            textBox3.Clear();
            if (textBox4.Text == "" && textBox5.Text == "")
            {
                MessageBox.Show("请输入取值范围!");
                return;
            }

            Random ran = new Random();
            int n1 = ran.Next(int.Parse(textBox4.Text), int.Parse(textBox5.Text));
            int n2 = ran.Next(int.Parse(textBox4.Text), int.Parse(textBox5.Text));
            if (n1 < 0) textBox1.Text += "(" + n1 + ")";
            else textBox1.Text += n1;
            textBox1.Text += "*";
            if (n2 < 0) textBox1.Text += "(" + n2 + ")";
            else textBox1.Text += n2;
        }

        private void RandomNumchu()
        {
            textBox1.Clear();
            textBox3.Clear();
            if (textBox4.Text == "" && textBox5.Text == "")
            {
                MessageBox.Show("请输入取值范围!");
                return;
            }

            Random ran = new Random();
            int n1 = ran.Next(int.Parse(textBox4.Text), int.Parse(textBox5.Text));
            int n2 = ran.Next(int.Parse(textBox4.Text), int.Parse(textBox5.Text));
            if (n1 < 0) textBox1.Text += "(" + n1 + ")";
            else textBox1.Text += n1;
            textBox1.Text += "/";
            if (n2 < 0) textBox1.Text += "(" + n2 + ")";
            else textBox1.Text += n2;
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            if (t <= 0)
            {
                timer1.Enabled = false;
                textBox3.Enabled = false;
                MessageBox.Show("时间到！");
                textBox3.Enabled = false;
                Form2 frm2 = new Form2();
                frm2.ShowDialog();
            }
            t = t - 1;
            label2.Text = t.ToString();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            timer1.Stop();
            Form2 frm2 = new Form2();
            frm2.ShowDialog();
        }

        private void button3_Click(object sender, EventArgs e)
        {
            RandomNumjia();
        }

        private void button4_Click(object sender, EventArgs e)
        {
            RandomNumjian();
        }

        private void button5_Click(object sender, EventArgs e)
        {
            RandomNumcheng();
        }

        private void button6_Click(object sender, EventArgs e)
        {
            RandomNumchu();
        }

        private void button7_Click(object sender, EventArgs e)
        {
            if (textBox4.Text == "" && textBox5.Text == "")
            {
                MessageBox.Show("请输入取值范围!");
                return;
            }
            else
            {
                for (int i = 0; i < int.Parse(textBox6.Text);i++)
                {
                    RDN();
                }
            }
        }

        private void textBox3_KeyDown(object sender, KeyEventArgs e)
        {
            string result = textBox1.Text;

            if (Count == int.Parse(textBox6.Text))
            {
                Form2 frm2 = new Form2();
                frm2.ShowDialog();
            }

            if (e.KeyCode == Keys.Enter)
            {
                if (textBox3.Text == Calucate(result).ToString())   //直接调用Calucate这个方法计算result的值并与输入的值进行比较
                {
                    right++;
                    Count++;
                    MessageBox.Show("回答正确！");
                }

                else
                {
                    MessageBox.Show("答题错误！");
                    Count++;
                    string s = textBox1.Text;
                    if (s.Substring(textBox4.TextLength, 1) == "+")
                    {
                        RandomNumjia();
                    }
                    else if (s.Substring(textBox4.TextLength, 1) == "-")
                    {
                        RandomNumjian();
                    }
                    else if (s.Substring(textBox4.TextLength, 1) == "*")
                    {
                        RandomNumcheng();
                    }
                    else if (s.Substring(textBox4.TextLength, 1) == "/")
                    {
                        RandomNumchu();
                    }
                    else if (s.Length > 5)
                    {
                        RDN();
                    }
                }

                string m = textBox1.Text;
                if (m.Substring(textBox4.TextLength, 1) == "+")
                {
                    RandomNumjia();
                }
                else if (m.Substring(1, 1) == "-")
                {
                    RandomNumjian();
                }
                else if (m.Substring(1, 1) == "*")
                {
                    RandomNumcheng();
                }
                else if (m.Substring(1, 1) == "/")
                {
                    RandomNumchu();
                }
                else if (m.Length > 5)
                {
                    RDN();
                }
            }
        }

        static Dictionary<char, int> priorities = null;  //优先级

        static void Calculator()                         //添加了四种运算符以及四种运算符的优先级
        {
            priorities = new Dictionary<char, int>();    
            priorities.Add('#', -1);                     
            priorities.Add('+', 0);
            priorities.Add('-', 0);
            priorities.Add('*', 1);
            priorities.Add('/', 1);
        } 

        const string operators = "+-*/";                 //运算符
        static double Compute(double leftNum, double rightNum, char op)  //这是一种方法，用来计算左右两个数的静态方法！
        {
            switch (op)
            {
                case '+': return leftNum + rightNum;
                case '-': return leftNum - rightNum;
                case '*': return leftNum * rightNum;
                case '/': return leftNum / rightNum;
                default: return 0;
            }
        }

        static bool IsOperator(char op)                  //每次判断这个字符是否是运算符？
        {
            return operators.IndexOf(op) >= 0;
        }

            static bool IsAssoc(char op)                //返回一个关联符号
        {
            return op == '+' || op == '-' || op == '*' || op == '/';
        }

        static Queue<object> QueueSort (string expression)           // 队列排序   
        {
            Queue<object> result = new Queue<object>();             
            Stack<char> operatorStack = new Stack<char>();           //运算符栈
            operatorStack.Push('#');
            char top, cur, tempChar;                                          //top栈顶，current最近的；
            string tempNum;
            for (int i = 0, j; i < expression.Length; )                 //取出表达式
            {
                cur = expression[i++];                                  //取出表达式的每个字符赋给cur
                top = operatorStack.Peek();                             //栈顶元素赋给top此时为"#"

                if (cur == '(')                                         //将左括号压栈,此时栈顶元素为"("
                {
                    operatorStack.Push(cur);
                }
                else
                {
                    if (IsOperator(cur))                             //如果是运算符的话
                    {
                        while (IsOperator(top) && ((IsAssoc(cur) && priorities[cur] <= priorities[top])) || (!IsAssoc(cur) && priorities[cur] < priorities[top]))
                        {
                            result.Enqueue(operatorStack.Pop());     //如果元素为运算符并且优先级小于栈顶元素优先级，出栈
                            top = operatorStack.Peek();              //继续把栈顶元素赋给top
                        }
                        operatorStack.Push(cur);                     //把数字压栈
                    }
                    else if (cur == ')')                           //将右括号添加到结尾
                    {
                        while (operatorStack.Count > 0 && (tempChar = operatorStack.Pop()) != '(')
                        {
                            result.Enqueue(tempChar);
                        }
                    }
                    else
                    {
                        tempNum = "" + cur;
                        j = i;
                        while (j < expression.Length && (expression[j] == '.' || (expression[j] >= '0' && expression[j] <= '9')))
                        {
                            tempNum += expression[j++];
                        }
                        i = j;
                        result.Enqueue(tempNum);
                    }
                }
            }
            while (operatorStack.Count > 0)
            {
                cur = operatorStack.Pop();
                if (cur == '#') continue;
                if (operatorStack.Count > 0)
                {
                    top = operatorStack.Peek();
                }

                result.Enqueue(cur);
            }

            return result;
        }

        static double Calucate(string expression)
        {
            try
            {
                var rpn = QueueSort(expression);                   //rpn逆波兰表达式reverse polish notation 
                Stack<double> operandStack = new Stack<double>();
                double left, right;
                object cur;
                while (rpn.Count > 0)
                {
                    cur = rpn.Dequeue();                           //出列
                    if (cur is char)                               //如果cur为字符的话
                    {
                        right = operandStack.Pop();                //右边的数字出栈
                        left = operandStack.Pop();                 //左边的数字出栈
                        operandStack.Push(Compute(left, right, (char)cur));    //此时调用compute方法
                    }
                    else
                    {
                        operandStack.Push(double.Parse(cur.ToString()));            //是数字就压栈
                    }
                }
                return operandStack.Pop();
            }
            catch
            {
                throw new Exception("表达式格式不正确！");
            }
        }

    }
}

代码编写过程：

Form2.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace _Random
{
    public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }

        private void Form2_Load(object sender, EventArgs e)
        {
            textBox1.Text = Form1.Count.ToString();
            textBox2.Text = Form1.right.ToString();
            textBox3.Text = (Form1.Count - Form1.right).ToString();
        }

    }
}

运行过程：

答题的时候给出取值范围，点击随机，程序会给出一个运算式，在等号后面的文本框
里面输入答案，这是会调用计算方法，并判断对错。

时间到了会给出测试结果。并提示时间到！

PSP耗时分析：

 

结对编程总结：

说明：我们一起做的是第五个增量。

  这次结对编程依然是我的老搭档张宇，总的来说他是一个比较优秀的搭档，对我的辅导也非常尽心，通过这两次结对编程我学到了很多知识，也了解了自己以前不知道的逆波兰表达式，这些多亏我的搭档给我讲解。说实话看到老师发的作业增量一次比一次难我都有放弃的想法，多亏搭档坚持。当看到增量作业一点头绪都没后来我们在网上查了一些资料才有所了解。通过这次编程我明白了所谓的迭代，代码永远都敲不完，客户的每一次需求，我们都要进行一次代码修改，还要保证之前的功能依然可以实现，所以程序员真的不是一个轻松的活。但是我想只要努力就可以成功！