第二次作业

git地址	https://github.com/JPL1988
git用户名	JPL1988
学号后5位	62131
博客链接	https://www.cnblogs.com/l123456l/p/10593365.html
作业链接	https://edu.cnblogs.com/campus/xnsy/SoftwareEngineeringClass1/homework/2793

Part 0. 背景

阿超家里的孩子上小学一年级了，这个暑假老师给家长们布置了一个作业：家长每天要给孩子出一些合理的，但要有些难度的四则运算题目，并且家长要对孩子的作业打分记录。

作为程序员的阿超心想，既然每天都需要出题，那何不做一个可以自动生成小学四则运算题目与解决题目的命令行 “软件”呢。他把老师的话翻译一下，就形成了这个软件的需求：

程序接收一个命令行参数 n，然后随机产生 n 道加减乘除（分别使用符号+-*/来表示）练习题，每个数字在 0 和 100 之间，运算符在 2 个到 3 个之间。
由于阿超的孩子才上一年级，并不知道分数。所以软件所出的练习题在运算过程中不得出现非整数，比如不能出现 3÷5+2=2.6 这样的算式。
练习题生成好后，将生成的 n 道练习题及其对应的正确答案输出到一个文件 subject.txt 中。
当程序接收的参数为4时，以下为一个输出文件示例。
```
13+17-1=29
11*15-5=160
3+10+4-16=1
15÷5+3-2=4
```

这次阿超选择使用他最拿手的 C++ 语言来完成这样的需求，工欲善其事必先利其器，第一步就需要先安装一个好用的 IDE ，在这里我们推荐使用 Visual Studio 2017。

代码设计思路

1.我通过random产生随机数和计算符，把每一个符号和数字存入字符串数组

2，把中缀表达式转为后缀表达式

3，,计算每个子表达式的值，若为负数或小数，删去整个表达式，重新取值。

程序代码

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
    class wuyu
    {
        public static void Main(string[] args)
        {
            Program program = new Program();
            program.Calculation(10000000);
        }
    }
    public class Program
    {
        StringBuilder lastresult = new StringBuilder();
        caculator caculators = new caculator();
        private Random random = new Random();
        public void Calculation(int n)
        {
            for (int i = 0; i < n; i++)
            {
                int sign = random.Next(2, 3);              
                if (sign == 2)
                    Calculation2();
                else
                    Calculation3();
            }
            System.IO.File.WriteAllText("D://homework.txt",lastresult.ToString(),Encoding.Default);

        }
        private void Calculation3()
        {
            string[] s = new string[5];
            int d = random.Next(1, 101);
            char z = getchar();
            StringBuilder str = two(s);
            str.Append(z);
            str.Append(d);
            int result = caculators.compute(s);
            if (result == -1)
                Calculation3();
            else
            {
                str.Append('=');
                str.Append(result);
                str.Append(' ');
                lastresult.Append(str);
            }           
        }
        public void Calculation2()
        {
            string[] s = new string[5];
            StringBuilder str = two(s);
            int result =caculators.compute(s);
            if (result == -1)
                Calculation2();
            else
            {
                str.Append('=');
                str.Append(result);
                str.Append(' ');
                lastresult.Append(str);
            }           
        }

        private char getchar()
        {
            Char res = '+';
            int x = random.Next(0, 4);
            switch (x)
            {
                case 1:
                    break;
                case 2:
                    res = '-';
                    break;
                case 3:
                    res = '*';
                    break;
                default:
                    res = '/';
                    break;
            }
            return res;
        }       
        public StringBuilder two(string[] strings)
        {
            int a = random.Next(1, 101);
            int b = random.Next(1, 101);
            int c = random.Next(1, 101);
            char x = getchar();
            char y = getchar();
            StringBuilder str = new StringBuilder();
            strings[0] = a.ToString();
            strings[1] = x.ToString();
            strings[2] = b.ToString();
            strings[3] = y.ToString();
            strings[4] = c.ToString();
            str.Append(a);
            str.Append(x);
            str.Append(b);
            str.Append(y);
            str.Append(c);
            return str;
        }
    }

    public class caculator
    {
        private static string Operator = "+-*/";
        Queue<string> postfix;//队列储存后缀表达式
        Stack<string> stack;//栈储存计算后缀表达式时的数字
        public int compute(string[] s)
        {
            convert(s);//计算后缀表达式
            stack = new Stack<string>(7);
            int symbol;
            int length = postfix.Count;
            for (int i = 0; i < length; i++)
            {
                symbol = isOperator(postfix.Peek());
                if (symbol > -1)//是否为操作符
                {
                    postfix.Dequeue();//把操作符从队列里面移除
                    int d2 = int.Parse(stack.Pop());
                    int d1 = int.Parse(stack.Pop());//取出数据进行计算
                    int d3 = 0;
                    switch (symbol)
                    {
                        case 0:
                            d3 = d1 + d2;
                            break;
                        case 1://排除负数结果
                            d3 = d1 - d2;
                            if (d3 < 0)
                                return -1;
                            break;
                        case 2:
                            d3 = d1 * d2;
                            break;
                        case 3://排除小数结果
                            d3 = d1 / d2;
                            if (d3 * d2 != d1)
                                return -1;
                            break;
                    }
                    stack.Push(d3.ToString());//将计算结果压入数字栈
                }
                else
                {
                    stack.Push(postfix.Dequeue());//将数字压入数字栈
                }
            }
            return int.Parse(stack.Pop());//返回最终结果
        }


        public void convert(string[] strings)
        {
            postfix = new Queue<string>(strings.Length);
            stack = new Stack<string>(7);
            for (int i = 0; i < strings.Length; i++)
            {
                String tempc = strings[i];
                if (i % 2 == 1)//说明是操作符
                {
                    if (stack.Count == 0)//栈为空则将数据直接压入计算符栈
                    {
                        stack.Push(tempc);
                    }
                    else
                    {//栈不为空则和栈顶符号的优先级比较，将比当前优先级高的符号移除，并加进后缀表达式
                        while (stack.Count != 0 && priority(tempc, stack.Peek()))
                        {
                            postfix.Enqueue(stack.Pop());
                        }
                        stack.Push(tempc);//将当前符号压入栈顶
                    }
                }
                else
                {
                    postfix.Enqueue(tempc);//若是数字则直接加进后缀表达式
                }
            }
            while (stack.Count > 0)
            {
                postfix.Enqueue(stack.Pop());//将剩余操作符加进后缀表达式
            }
        }

        public int isOperator(string c)
        {
            return Operator.IndexOf(c);
        }

        public bool priority(String o1, String o2)
        {
            return getPriority(o1) <= getPriority(o2);
        }

        public int getPriority(String c)
        {
            switch (c)
            {
                case "+":
                case "-":
                    return 1;
                default:
                    return 2;
            }
        }
    }
}

Part 1. 配置环境

最开始安装成了企业版，然后有个插件安装失败，也不能使用，重装几次的时候发现装错了版本。

Part 2. 克隆项目

拷贝成功，我的用户名JPL1988

安装git，克隆到本地，最开始安装的Git的桌面版，然后重新装的bash版

part3,单元测试

在单元测验时，遇到了一个较大的问题，那就是被测试的类如果确实静态Main方法无法被测试，报确实静态Main方法错误，但是由于之前做Java测试不需要Main方法。最后发现他人博客里的测试都要一个空类和空的Main方法，然后才测试成功。只是还不明白为什么，也没有查到。

单元测试运行

单元测试代码

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using ConsoleApp1;

namespace UnitTestcalculator
{   
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            caculator ca = new caculator();
            string[] s = new string[] {"1","-","5","*","8" };
            Assert.IsTrue(ca.compute(s)==-1);
        }
        [TestMethod]
        public void TestMethod2()
        {
            caculator ca = new caculator();
            string[] s = new string[] { "1", "+", "5", "*", "8" };
            Assert.IsTrue(ca.compute(s) == 41);
        }
        [TestMethod]
        public void TestMethod3()
        {
            caculator ca = new caculator();
            string[] s = new string[] { "1", "/", "5", "*", "8" };
            Assert.IsTrue(ca.compute(s) == -1);
        }
        [TestMethod]
        public void TestMethod4()
        {
            caculator ca = new caculator();
            string[] s = new string[] { "5", "/", "1", "*", "8" };
            Assert.IsTrue(ca.compute(s) == 40);
        }
        [TestMethod]
        public void TestMethod5()
        {
            caculator ca = new caculator();
            string[] s = new string[] { "1", "*", "5", "+", "8" };
            Assert.IsTrue(ca.compute(s) == 13);
        }
    }
}