软件工程第一次实践——使用C#开发科学计算器

已于 2023-10-01 17:16:08 修改
阅读量502 收藏 8
点赞数 3
文章标签： 软件工程 c# 大作业
于 2023-09-29 15:39:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/saiyuan233/article/details/133394888
版权

文章目录

作业基本信息

这个作业属于哪个课程https://bbs.csdn.net/forums/ssynkqtd-05
这个作业要求在哪里https://bbs.csdn.net/topics/617294583
这个作业的目标完成一个具有可视化界面的计算器

Gitcode项目地址

https://gitcode.net/saiyuan233/mycalculator/-/tree/master/

项目功能展示

MyCalculator演示

PSP表格

PSPPersona Software Process Stages预估耗时（分钟）实际耗时（分钟）
Planning计划3020
• Estimate• 估计这个任务需要多少时间3020
Development开发460760
• Analysis• 需求分析 (包括学习新技术）3020
• Design Spec• 生成设计文档3035
• Design Review• 设计复审3020
• Coding Standard• 代码规范 (为目前的开发制定合适的规范)1010
• Design• 具体设计3045
• Coding• 具体编码300420
• Code Review• 代码复审3030
• Test• 测试（自我测试，修改代码，提交修改）120180
Reporting报告6040
• Test Repor• 测试报告3020
• Size Measurement• 计算工作量1010
• Postmortem & Process Improvement Plan• 事后总结, 并提出过程改进计划20210
合计550820

解题思路描述

要求实现一个具有图形化界面的计算器，在实现普通的加减乘除四则运算的基础上，进一步实现科学计算器的相关内容，包括次方、幂、三角函数等相关操作。

由于本次实践要求进行图形化开发，个人选择使用C#以及.NET进行开发

解题思路如下：
1.创建WPF项目，利用Text Box、Button等控件，创建GUI界面，并配置各个控件的属性。
2.通过触发各控件的事件进行表达式输入、运算以及结果输出。
3.表达式结果计算方法：首先扫描表达式，将表达式分割成多个子项，并将子项中隐含的操作数以及操作符补全，例如输入2sin(1)+23，将通过自己编写的分割函数将该表达式补全并分割为2sin(1)、2*3两个子项。接着通过堆栈方式，将各个子项转化为后缀表达式并计算。最后将各个子项相加即为最终结果。
4.在实现复杂表达式的分割时，需要对可能存在的特殊情况进行特判并处理，以便对各个子项求值。

接口设计和实现过程

1.通过工具箱生成TextBox和Button控件，使用XAML语言修改布局，双击控件进入控件的触发事件函数，完成各事件的响应。
2.设计item_divide()函数，将需处理的表达式传入该函数，进行子项分割。
3.设计Caculate（）函数，将存放子项的字符串数组传入该函数，进行结果运算。

核心代码

表达式分割：

public static void item_divide(string input, out string[] items, out int sum)
{
    string expression = "";
    items = new string[233];
    sum = 0;
    char temp;
    input += "#";
    int couples = 0;
    for (int i = 0; input[i] != '#'; i++)
    {
        temp = input[i];
        if(temp >= '0' && temp <= '9' && (input[i+1] >= 'a' && input[i+1] <= 'z'  || input[i+1] == '('))
        {
            expression = expression + temp + '*';
        }
        else if(temp >= 'a' && temp <= 'z' && input[i + 1] >= 'a' && input[i + 1] <= 'z')
        {
            string alpha = "";
            alpha += temp;
            while (input[i+1] >= 'a' && input[i+1] <= 'z')
            {
                alpha += input[i + 1];
                i++;
            }
            while(alpha.Length != 0)
            {
                switch(alpha)
                {
                    case "sin":
                        expression += "sin";
                        alpha = "";
                        break;
                    case "cos":
                        expression += "cos";
                        alpha = "";
                        break;
                    case "tan":
                        expression += "tan";
                        alpha = "";
                        break;
                    case "abs":
                        expression += "abs";
                        alpha = "";
                        break;
                    case "lg":
                        expression += "lg";
                        alpha = "";
                        break;
                }
            }
        }
        else if(temp == '(')
        {
            expression += temp;
            couples++;
            if (input[i+1] == '-' && (input[i+2] >= 'a' && input[i+2] <= 'z'))
            {
                expression += "0-1*";
                i++;
            }
            else if (input[i + 1] == '-' && (input[i + 2] >= '0' && input[i + 2] <= '9'))
            {
                expression += "0-";
                i++;
            }   
        }
        else if(temp == ')')
        {
            expression += temp;
            couples--;
        }
        else
        {
            if(couples == 0 && (temp == '+' || temp == '-'))
            {
                items[sum] = expression;
                sum++;
                expression = Convert.ToString(temp);
            }
            else
            {
                expression += temp;
            }
        }
    }
    items[sum] = expression;
    sum++;
}

子项结果计算：

public static double Caculate(string[] items, int sum)
{
    Stack<double> data = new Stack<double>();
    Stack<string> ope = new Stack<string>();
    double result = 0;
    char temp;
    string alpha;
    int flag = 0;
    while(sum > 0)
    {
        alpha = "";
        items[--sum] += '#';
        data.Clear();
        ope.Clear();
        data.Push(0); // 栈底元素为0，便于处理负数 
        for(int i = 0; items[sum][i] != '#'; i++)
        {   
            temp = items[sum][i];
            alpha += temp;
            if(temp >= '0' && temp <= '9')
            {
                while (items[sum][i] != '#')
                {
                    if (items[sum][i+1] >= '0' && items[sum][i+1] <= '9' || items[sum][i+1] == '.')
                    {
                        alpha += items[sum][i + 1];
                        i++;
                    }
                    else
                    {
                        break;
                    }
                }
                data.Push(Convert.ToDouble(alpha));
            }
            else if(temp >='a' && temp <= 'z')
            {
                while (items[sum][i] != '#')
                {
                    if (items[sum][i+1] >= 'a' && items[sum][i+1] <= 'z')
                    {
                        alpha += items[sum][i+1];
                        i++;
                    }
                    else
                    {
                        break;
                    }
                }
                ope.Push(alpha);
            }
            else if(temp == ')')
            {
                string now_ope;
                while (ope.Count() != 0 && !ope.Peek().Equals("("))
                {
                    now_ope = ope.Pop();
                    if (now_ope.Equals("+"))
                    {
                        data.Push(data.Pop() + data.Pop());
                    }
                    else if (now_ope.Equals("-"))
                    {
                        data.Push(-data.Pop() + data.Pop()); // 注意操作数顺序
                    }
                    else if (now_ope.Equals("*"))
                    {
                        data.Push(data.Pop() * data.Pop());
                    }
                    else if (now_ope.Equals("/")) // 注意操作数顺序
                    {
                        data.Push(1/data.Pop() * data.Pop());
                    }
                    else if (now_ope.Equals("^")) // 注意操作数顺序
                    {
                        double second_num = data.Pop();
                        data.Push(Math.Pow(data.Pop(), second_num));
                    }
                    else if (now_ope.Equals("sin"))
                    {
                        data.Push(Math.Sin(data.Pop()));
                    }
                    else if (now_ope.Equals("cos"))
                    {
                        data.Push(Math.Cos(data.Pop()));
                    }
                    else if (now_ope.Equals("tan"))
                    {
                        data.Push(Math.Tan(data.Pop()));
                    }
                    else if (now_ope.Equals("abs"))
                    {
                        data.Push(Math.Abs(data.Pop()));
                    }
                    else if (now_ope.Equals("lg"))
                    {
                        data.Push(Math.Log2(data.Pop()));
                    }
                }
                if(ope.Count() != 0 && ope.Peek().Equals("("))
                {
                    ope.Pop();
                }
            }
            else
            {
                switch (alpha)
                {
                    case "+":
                    case "-":
                        while(ope.Count != 0 && !ope.Peek().Equals("("))
                        {
                            string now_ope;
                            now_ope = ope.Pop();
                            if (now_ope.Equals("+"))
                            {
                                data.Push(data.Pop() + data.Pop());
                            }
                            else if (now_ope.Equals("-"))
                            {
                                data.Push(-data.Pop() + data.Pop()); // 注意操作数顺序
                            }
                            else if (now_ope.Equals("*"))
                            {
                                data.Push(data.Pop() * data.Pop());
                            }
                            else if (now_ope.Equals("/")) // 注意操作数顺序
                            {
                                data.Push(1 / data.Pop() * data.Pop());
                            }
                            else if (now_ope.Equals("^")) // 注意操作数顺序
                            {
                                double second_num = data.Pop();
                                data.Push(Math.Pow(data.Pop(), second_num));
                            }
                            else if (now_ope.Equals("sin"))
                            {
                                data.Push(Math.Sin(data.Pop()));
                            }
                            else if (now_ope.Equals("cos"))
                            {
                                data.Push(Math.Cos(data.Pop()));
                            }
                            else if (now_ope.Equals("tan"))
                            {
                                data.Push(Math.Tan(data.Pop()));
                            }
                            else if (now_ope.Equals("abs"))
                            {
                                data.Push(Math.Abs(data.Pop()));
                            }
                            else if (now_ope.Equals("lg"))
                            {
                                data.Push(Math.Log2(data.Pop()));
                            }
                        }
                        ope.Push(alpha);
                        break;
                    case "*":
                    case "/":
                        while(ope.Count != 0 &&  ope.Peek() != "(")
                        {
                            string now_ope;
                            now_ope = ope.Pop();
                            if (now_ope.Equals("*"))
                            {
                                data.Push(data.Pop() * data.Pop());
                            }
                            else if (now_ope.Equals("/")) // 注意操作数顺序
                            {
                                data.Push(1 / data.Pop() * data.Pop());
                            }
                            else if (now_ope.Equals("^")) // 注意操作数顺序
                            {
                                double second_num = data.Pop();
                                data.Push(Math.Pow(data.Pop(), second_num));
                            }
                            else if (now_ope.Equals("sin"))
                            {
                                data.Push(Math.Sin(data.Pop()));
                            }
                            else if (now_ope.Equals("cos"))
                            {
                                data.Push(Math.Cos(data.Pop()));
                            }
                            else if (now_ope.Equals("tan"))
                            {
                                data.Push(Math.Tan(data.Pop()));
                            }
                            else if (now_ope.Equals("abs"))
                            {
                                data.Push(Math.Abs(data.Pop()));
                            }
                            else if (now_ope.Equals("lg"))
                            {
                                data.Push(Math.Log2(data.Pop()));
                            }
                        }
                        ope.Push(alpha);
                        break;
                    case "^":
                        ope.Push(alpha);
                        break;
                    case "(":
                        ope.Push(alpha);
                        break;
                }
            }
            alpha = "";
        }
        while(ope.Count != 0)
        {
            alpha = ope.Pop();
            if (alpha.Equals("+"))
            {
                data.Push(data.Pop() + data.Pop());
            }
            else if(alpha.Equals("-"))
            {
                data.Push(-data.Pop() + data.Pop());
            }
            else if (alpha.Equals("*"))
            {
                data.Push(-data.Pop() * data.Pop());
            }
            else if (alpha.Equals("/"))
            {
                data.Push(1/data.Pop() * data.Pop());
            }
            else if (alpha.Equals("^"))
            {
                double second_num = data.Pop();
                data.Push(Math.Pow(data.Pop(), second_num));
            }
            else if (alpha.Equals("sin"))
            {
                data.Push(Math.Sin(data.Pop()));
            }
            else if (alpha.Equals("cos"))
            {
                data.Push(Math.Cos(data.Pop()));
            }
            else if (alpha.Equals("tan"))
            {
                data.Push(Math.Tan(data.Pop()));
            }
            else if (alpha.Equals("abs"))
            {
                data.Push(Math.Abs(data.Pop()));
            }
            else if (alpha.Equals("lg"))
            {
                data.Push(Math.Log2(data.Pop()));
            }
        }
        result += data.Peek();
    }
    return result;
}

性能改进

通过括号匹配原则，按照各运算符优先级完成三角函数、自然对数、绝对值的嵌套运算，对负号进行判定，区分负数与减法；补全表达式中隐含的运算数以及运算符。

单元测试

单元测试代码：

public void CaculateTest()
{
    string[] items1 = { "(sin(0.5*2))^2", "(cos(0.5/0.5))^2" };
    if (MainWindow.Caculate(items1, 2) != 1)
    {
        Assert.Fail();
    }

    string[] items2 = { "(4*sin(1))^2", "(4*cos(1))^2" };
    if(MainWindow.Caculate(items2, 2) != 16)
    {
        Assert.Fail();
    }

    string[] items3 = { "-1*tan(2*cos(-1))+1" , "tan(2*cos(-1))" };
    if (MainWindow.Caculate(items3, 2) != 1)
    {
        Assert.Fail();
    }

    double ans4 = Math.Tan(Math.Sin(Math.Cos(1)));
    string[] items4 = { "tan(sin(cos(1)))" };
    if( MainWindow.Caculate(items4, 1) != ans4)
    {
        Assert.Fail();
    }

    string[] items5 = { "abs(lg(1/2))" };
    if (MainWindow.Caculate(items5, 1) != 1)
    {
        Assert.Fail();
    }
}

测试结果：

MyCalculator测试结果

心路历程与收获

本次作业是个人第一次接触图形化开发，本次实践也让我学习了如何进行单元测试以及如何将程序打包成可执行文件。在实现作业要求的计算器的运算功能时，我选择利用栈，将中缀表达式转化为后缀表达式进行运算，由于要实现的运算功能较多，在优先级设置方面一开始没有考虑周全，在进行单元测试时也发现有部分特殊输入没有考虑到。在跟舍友同学交流过程中，逐步完善功能，也算是对关于栈的数据结构做了一点简单的复习。

sai源
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C#实例 —— 设计一个科学计算器 （WPF界面实现）
weixin_45525142的博客
04-28 1207
C#实例 —— 设计一个科学计算器 （WPF界面实现）
C#之简易计算器的制作
热门推荐
凭时间赢来的东西，时间肯定会为之作证
03-19 14万+
在一些问题中有时会用到计算器,今天我们可以用C#做一个简易的计算器 用到的开发工具为Visual Studio 2019(我用的是2019,其他版本的也可以) 1.首先新建一个项目文件. 2.在Form1.cs文件(Winform框架基础文件)中添加所用到的控件. 3.添加TextBox和ComboBox以及Button控件 4.对Button以及ComboBox进行一些简单的设置 ......
《Visual Studio Installer》C#上位机程序设计出一个计算器_visual studio做一个计算器
最新发布
2401_84009192的博客
05-13 955
随着科学技术的发展，我们手机里的计算器也越来越强大，不仅可以实现加、减、乘、除的计算功能，还延伸出了汇率计算。同时数学公式是书写，各类符号也在计算器里可以看见，还有了专属于程序员的二级制、十进制、十六进制的换算，在未来的一天，我们的计算器还会出现许多新奇的功能，我们也会体验得到。正是在这种情况下，我们这次有了一个有趣的任务，实现一个计算器的设计，帮助大家去理解这计算背后的逻辑，让大家对计算器计算有一个大致的理解。
c#计算器
m0_65451009的博客
11-30 2061
C#计算器!
C#科学计算器
01-01
用C#实现可视化的科学计算器，支持四则运算，各种三角函数运算，开方运算等常见计算器功能。
【实验01 扩展实验】C#桌面项目：简易计算器
ruarua的成长之旅
03-18 822
（3）（选做）改进程序的设计，要求输入一个算术表达式，点击“=”按钮完成输入表达式的计算并输出（可以利用数据结构中的表达式计算原理，实现表达式的计算）。（2）计算方式：通过点击对应的按钮，输入第1个数（可以是整数或实数），输入运算符（+、-、*或/），再输入第2个数，点击“=”按钮，完成计算。（1）新建一个C#桌面项目Calc，实现简易计算器功能，界面如图1所示。不知道为什么录屏没给我录到头顶，将就看看。【Form1.cs代码】红色为每个按钮的方法名。
周立功USBCAN二次开发套件——供C#开发使用
04-26
这个是周立功官网给出的USBCAN二次开发套件库。内含文件ControlCAN.dll等
基于C#winfrom开发的科学计算器
11-21
在本文中，我们将深入探讨如何使用C# Winform框架开发一个功能丰富的科学计算器以及一个专门针对贷款计算的应用。首先，让我们了解C# Winform的基本概念。 C# Winform是.NET Framework的一部分，它提供了一个用于...
C#-简单计算器.zip
07-01
在本项目中，我们讨论的是一个使用C#编程语言...总的来说，这个C#简单计算器项目是一个很好的学习资源，它涵盖了C#编程基础、Windows Forms应用开发以及事件驱动编程的概念，对于初学者来说，是一个理想的实践项目。
C#简单及科学计算器
03-16
总的来说，“C#简单及科学计算器”项目是一个很好的学习实践平台，涵盖了C#编程基础、Windows Forms应用开发、运算符优先级、事件驱动编程、文本转语音等多个方面的知识。通过完成这个项目，你不仅可以提升C#编程...
C#实现的科学/标准型两用计算器
08-04
这是用C#编写的计算器，可以通过快捷键或按钮等实现标准型计算或科学型计算的模式切换（模式的不同即是否考虑算符优先）。该计算器有右键菜单功能，键盘响应功能，鼠标移动功能，有分行显示用户输入及计算结果的输出。这是简单的程序代码，主要包括重要的功能性函数，供学习使用。通过修改代码可以整合成更好的计算器实例，内有详细的项目文档。学习中遇到的问题可以发邮件到369068199@qq.com讨论。
C#科学计算器源码
01-29
多功能C#科学计算器，有乘方、开方、三角函数、反三角函数、双曲函数、对数。
c#实现一个计算器
04-17
c#实现一个计算器，可以实现连加、连乘、连除等功能
C#控制台实现计算器案例 c#经典案例.pdf
05-07
C#控制台实现计算器案例 c#经典案例.pdf
C#计算器（科学型，简单型）
04-27
实验题目：计算器实验 二、实验目的： 1）熟悉.NET的编程方法，掌握项目的创建与使用及安装； 2）熟悉C#编程语言，字符串使用、自定义类、自定义类库等； 3）熟悉Windows应用程序类编程、事件驱动编程； 三、实验内容： 1）参照Windows提供的计算器工具，设计一个与之类似的程序；另外可参考运行效果下载（计算器Demo程序）； 2）基本要求：实现“普通运算”功能，支持连续运算，如连续输入“2+3×5”后点击“等号”按钮进行运算其结果为25. 3）附加要求： A,支持“科学运算”功能，即输入表达式时遵循运算符号的优先原则，连续输入“2+3×5”后点击“等号”按钮进行运算其结果为17； B,支持数字键盘（小键盘）输入功能(焦点不在文本框内时也支持键盘输入)； 四、实验方法 经过用户的输入得到数学表达式后，可选择以下方法计算结果： 方法1）不定义计算类方法，在程序中直接计算出结果。 方法2）在项目中设计一个计算类（CalculateClass），其中包含“普通计算”和“科学计算”功能，即输入数学运算表达式字符串，返回计算结果。直接在项目中调用该类，输出计算结果。 方法3）在解决方案中增加一个类库（ClassLibrary）项目（在bin\debug下生成dll文件），其中包含计算类（CalculateClass），该类中包含两个方法（普通计算和科学计算），可以根据表达式计算结果。然后在计算器项目中“引用”该类库中的类，输出计算结果； 点评：方法1代码重用性差；方法2代码重用性好，在项目内可方便使用；方法3代码重用性较好，能在不同的项目内重用。 五、实验说明 1）认真分析总结每个“按钮”点击之后的动作（对应的代码）； 2）代码的共享：如数字按钮可以共享一个事件代码； 3）考虑操作性或实用性，如支持退格键、异常输入处理等； 4）为突出实验重点，可以不考虑数制转换、复合运算、括号运算等功能； 5）支持小键盘输入时，留意理解窗口的KeyPreview属性，即是否窗口接收键盘事件。另外实现时会涉及到“焦点隐藏”问题，以及按钮的键盘事件等。 6）“麻雀虽小，五脏俱全”，程序很容易出Bug，请认真调试； 7）要想达到界面有特点，不亚于在功能上下功夫。
用c#实现简易的计算器功能
meng鱼的博客
05-12 4万+
由于今天在网上搜了一下c#写的计算器，发现大多都太繁琐了，很多没必要并且不容易理解的东西就专门写了这个博客 1.首先新建一个windows窗体应用的项目。执行文件-新建-项目-windows窗体应用 2.在工具箱中拖出一个textbox用于输入和显示，再拖出21个button按钮用来当计算器的按键，改一下按钮的text属性 3.双击数字按钮进入代码界面（数字只用一个事件即可，运算符也是用一个事件，...
基于C#语言的计算器的设计与实现
BY110919980728的博客
08-11 457
利用c#语言实现一个计算器程序，包括普通计算器模式、科学计算器模式；实现实数（包括正数、负数、0）的加、减、乘、除、平方等基本远算，并实现非负数的开方运算。
普通计算器和科学计算器的实现过程另附带画图功能(C# 窗体)
weixin_45791896的博客
10-22 1071
有关科学计算器的方法设计(C#) 这只是一个纯小白的自治计算器,如有不足之处,勿骂. 计算器的实现有关科学计算器的方法设计(C#)有关普通计算器和科学计算器的代码如下画图功能的实现如下 有关普通计算器和科学计算器的代码如下 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using S
C#普通计算器与科学计算器
u010435905的专栏
06-05 2836
一． 功能   1）基本功能：实现“普通运算”功能，支持连续运算，如连续输入“2+3×5”后点击“等号”按钮进行运算其结果为25.   2）附加功能： A,支持“科学运算”功能，即输入表达式时遵循运算符号的优先原则，连续输入“2+3×5”后点击“等号”按钮进行运算其结果为17； B,支持数字键盘（小键盘）输入功能(焦点不在文本框内时也支持键盘输入)；
使用C#开发ActiveX控件
06-06
传统的ActiveX控件开发通常采用C++或Visual Basic，但本文探讨的是使用C#这一现代编程语言来开发ActiveX控件。 C#开发ActiveX控件的优势在于其简洁的语法和强大的.NET Framework支持。然而，这种方式也存在一些挑战...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值