项目一 ：简单计算器的实现

已于 2023-09-21 14:27:20 修改
阅读量79 收藏 1
点赞数
文章标签： c++
于 2023-09-07 00:30:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63475854/article/details/132724805
版权

  预习日志

1.1 项目目标和主要内容
1 ）学习图形界面的设计，利用 MFC 应用程序（ Java swing 或 QT
框架，或 C# ）创建基于对话框的应用程序，添加按钮、编辑框等控件；
2 ）能通过设计的按钮控件输入并实现简单算术运算，要求表达式在
编辑框中显示，能将运算结果，输出在编辑框内显示；并保存历史的表
达式运算记录。
3 ）也能够实现混合运算的算术表达式求解，算术表达式中包括加、
减、乘、除、括号等运算符；并且能够识别括号，优先级正确。
1.2 项目的主要功能
1 ）计算器能够实现混合运算的算术表达式求解；
2 ）输入时有足够的容错机制，来尽量避免用户输入不合规的算术表
达式
1.3项目具体思路

1 设置窗口大小以及缓冲区大小

2 绘制整体界面

3 采用字符串保存数字字符

4 清空输入 输出区字符

5 其他功能 回退，清空，等于

代码实现

calculator.h文件

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include<QPushButton>
#include<QLineEdit>
#include<QHBoxLayout>
#include<QVBoxLayout>
#include<QGridLayout>
#include<QString>
#include<QStack>
#include<QTime>
#include<iterator>
class calculator : public QMainWindow
{
    Q_OBJECT

public:
    calculator(QWidget *parent = 0);
    ~calculator();

private:
      QLineEdit *inputLine;
    QLineEdit *historyList;

      QString input="0"; 
      bool flat=false;

      QPushButton *zeroButton;
      QPushButton *oneButton;
      QPushButton *twoButton;
      QPushButton *threeButton;
      QPushButton *fourButton;
      QPushButton *fiveButton;
      QPushButton *sixButton;
      QPushButton *sevenButton;
      QPushButton *eightButton;
      QPushButton *nineButton;


      QPushButton *addButton;
      QPushButton *subButton;
      QPushButton *divButton;
      QPushButton *mulButton;
      QPushButton *equButton;
      QPushButton *decButton;
      QPushButton *botButton;

      QPushButton *CEButton;
      QPushButton *ACButton;
      QPushButton *CButton;
      QPushButton *lefButton;
      QPushButton *rigButton;

private slots:

      void buttonZeroClicked();
      void buttonOneClicked();
      void buttonTwoClicked();
      void buttonThreeClicked();
      void buttonFourClicked();
      void buttonFiveClicked();
      void buttonSixClicked();
      void buttonSevenClicked();
      void buttonEightClicked();
      void buttonNineClicked();


      void buttonAddClicked();
      void buttonSubClicked();
      void buttonMulClicked();
      void buttonDivClicked();
      void buttonDecClicked();
      void buttonBotClicked(); 

      void buttonEquClicked();

      void buttonLefClicked();
      void buttonRigClicked();

      void buttonCEClicked();
      void buttonCClicked();
      void buttonACClicked();
};

#endif // MAINWINDOW_H

calculator.cpp文件

#include "calculator.h"
#include<iostream>
using namespace std;
#include<stack>
#include<vector>
#include<cstdlib>
#include<limits.h>
#pragma execution_character_set("utf-8")
bool isNum(char ch);
bool isOperate(char ch);
int level(char ch);
double scd(string s);
double getValue(vector<string> V);
vector<string> midToPost(string s);

calculator::calculator(QWidget *parent) : QMainWindow(parent)
{


       QWidget *widget=new QWidget;
       this->setCentralWidget(widget);

       inputLine=new QLineEdit;
       inputLine->setText(input);
       historyList = new QLineEdit;

       zeroButton=new QPushButton("0");
       oneButton=new QPushButton("1");
       twoButton=new QPushButton("2");
       threeButton=new QPushButton("3");
       fourButton=new QPushButton("4");
       fiveButton=new QPushButton("5");
       sixButton=new QPushButton("6");
       sevenButton=new QPushButton("7");
       eightButton=new QPushButton("8");
       nineButton=new QPushButton("9");
       decButton=new QPushButton(".");

       addButton=new QPushButton("+");
       subButton=new QPushButton("-");
       mulButton=new QPushButton("*");
       divButton=new QPushButton("/");
       equButton=new QPushButton("=");

       lefButton=new QPushButton("(");
       rigButton=new QPushButton(")");
       CEButton=new QPushButton("CE");
       ACButton=new QPushButton("AC");
        CButton=new QPushButton("C");

       QGridLayout *H=new QGridLayout(this);

       inputLine->setFixedHeight(50);
     historyList->setFixedHeight(50);

       H->addWidget(inputLine,0,0,1,5);
       H->addWidget(historyList,5,0,1,4);
       H->setRowStretch(0,100);
       CButton->setFixedHeight(50);



       H->addWidget(oneButton,1,0);
       H->addWidget(twoButton,1,1);
       H->addWidget(threeButton,1,2);
       H->addWidget(CEButton,1,3);
       H->addWidget(ACButton,1,4);

       H->addWidget(fourButton,2,0);
       H->addWidget(fiveButton,2,1);
       H->addWidget(sixButton,2,2);
       H->addWidget(addButton,2,3);
       H->addWidget(subButton,2,4);

       H->addWidget(sevenButton,3,0);
       H->addWidget(eightButton,3,1);
       H->addWidget(nineButton,3,2);
       H->addWidget(mulButton,3,3);
       H->addWidget(divButton,3,4);

       H->addWidget(zeroButton,4,0);
       H->addWidget(decButton,4,1);
       H->addWidget(lefButton,4,2);
       H->addWidget(rigButton,4,3);
       H->addWidget(equButton,4,4);
          H->addWidget(CButton,5,4);

       widget->setLayout(H);

       connect(zeroButton,SIGNAL(clicked()),this,SLOT(buttonZeroClicked()));
       connect(oneButton,SIGNAL(clicked()),this,SLOT(buttonOneClicked()));
       connect(twoButton,SIGNAL(clicked()),this,SLOT(buttonTwoClicked()));
      connect(threeButton,SIGNAL(clicked()),this,SLOT(buttonThreeClicked()));
       connect(fourButton,SIGNAL(clicked()),this,SLOT(buttonFourClicked()));
       connect(fiveButton,SIGNAL(clicked()),this,SLOT(buttonFiveClicked()));
       connect(sixButton,SIGNAL(clicked()),this,SLOT(buttonSixClicked()));
       connect(sevenButton,SIGNAL(clicked()),this,SLOT(buttonSevenClicked()));
       connect(eightButton,SIGNAL(clicked()),this,SLOT(buttonEightClicked()));
       connect(nineButton,SIGNAL(clicked()),this,SLOT(buttonNineClicked()));

       connect(addButton,SIGNAL(clicked()),this,SLOT(buttonAddClicked()));
       connect(subButton,SIGNAL(clicked()),this,SLOT(buttonSubClicked()));
       connect(mulButton,SIGNAL(clicked()),this,SLOT(buttonMulClicked()));
       connect(divButton,SIGNAL(clicked()),this,SLOT(buttonDivClicked()));



       connect(decButton,SIGNAL(clicked(bool)),this,SLOT(buttonDecClicked()));

       connect(lefButton,SIGNAL(clicked(bool)),this,SLOT(buttonLefClicked()));
       connect(rigButton,SIGNAL(clicked(bool)),this,SLOT(buttonRigClicked()));

       connect(CEButton,SIGNAL(clicked()),this,SLOT(buttonCEClicked()));
       connect(ACButton,SIGNAL(clicked()),this,SLOT(buttonACClicked()));
       connect(CButton,SIGNAL(clicked()),this,SLOT(buttonCClicked()));

       connect(equButton,SIGNAL(clicked()),this,SLOT(buttonEquClicked()));

}

void calculator::buttonZeroClicked()
{
    if(input=="0")
    input='0';
    else input=input+'0';
    inputLine->setText(input);
}

void calculator::buttonOneClicked()
{
    if(input=="0")
    input='1';
    else input=input+'1';
    inputLine->setText(input);
}

void calculator::buttonTwoClicked()
{
    if(input=="0")
    input='2';
    else input=input+'2';
    inputLine->setText(input);
}

void calculator::buttonThreeClicked()
{
    if(input=="0")
    input='3';
    else input=input+'3';
    inputLine->setText(input);
}

void calculator::buttonFourClicked()
{
    if(input=="0")
    input='4';
    else input=input+'4';
    inputLine->setText(input);
}

void calculator::buttonFiveClicked()
{
    if(input=="0")
    input='5';
    else input=input+'5';
    inputLine->setText(input);
}

void calculator::buttonSixClicked()
{
    if(input=="0")
    input='6';
    else input=input+'6';
    inputLine->setText(input);
}

void calculator::buttonSevenClicked()
{
    if(input=="0")
    input='7';
    else input=input+'7';
    inputLine->setText(input);
}

void calculator::buttonEightClicked()
{
    if(input=="0")
    input='8';
    else input=input+'8';
    inputLine->setText(input);
}

void calculator::buttonNineClicked()
{
    if(input=="0")
    input='9';
    else input=input+'9';
    inputLine->setText(input);
}

void calculator::buttonAddClicked()
{
    if(input=="0")
    input='+';
    else input=input+'+';
    inputLine->setText(input);
}

void calculator::buttonSubClicked()
{
    if(input=="0")
    input='-';
    else input=input+'-';
    inputLine->setText(input);
}

void calculator::buttonMulClicked()
{
    if(input=="0")
    input='*';
    else input=input+'*';
    inputLine->setText(input);
}

void calculator::buttonDivClicked()
{
    if(input=="0")
    input='/';
    else input=input+'/';
    inputLine->setText(input);
}



void calculator::buttonDecClicked()
{
    if(input=="0")
    input='.';
    else input=input+'.';
    inputLine->setText(input);
}

void calculator::buttonBotClicked()
{
      if(input=="0")
        input='-';
      else
      {
      QString::iterator p=input.end();
        p--;
        if('-'==*p)
        input=input.left(input.length()-1);
        else input=input+'-';
     }
     inputLine->setText(input);
}

void calculator::buttonLefClicked()
{
    if(input == "0")
    {
        input = "(";
    }
    else
    {


        char lastChar = input.back().toLatin1();



        if(lastChar == '+' || lastChar == '-' || lastChar == '*' || lastChar == '/'||lastChar=='('||lastChar==')')
        {
            input = input + "(";
        }
        else
        {

            input = input + "=syntax error";
            inputLine->setText(input);
            return;
        }
    }

    inputLine->setText(input);
}


void calculator::buttonRigClicked()
{
    if(input == "0")
    {
        input = ")";
    }
    else
    {

        char lastChar = input.back().toLatin1();

        if(isNum(lastChar)||lastChar=='('||lastChar==')')
        {
            input = input + ")";
        }
        else
        {

            input = input + "=syntax error";
            inputLine->setText(input);
            return;
        }
    }
    inputLine->setText(input);
}


void calculator::buttonCEClicked()
{
    input = input.left(input.length()-1);
    inputLine->setText(input);
}
void calculator::buttonACClicked()
{
    input = "0";
    inputLine->setText(input);
}

void calculator::buttonCClicked()
{
     historyList->clear();
}

void calculator::buttonEquClicked()
{
    string inputTemp = input.toStdString();
    vector<string> expression = midToPost(inputTemp);
    double value = getValue(expression);
    if(value != INT_MAX)
    {
        input = input + "=" + QString::number(value);
        inputLine->setText(input);
        QString history = historyList->text();
        if(history.isEmpty())
  {
       historyList->setText(input);
  }
  else
  {
      historyList->setText(history + "\n" + input);
  }
}
    else { input = input + "=syntax error"; inputLine->setText(input);
    }
}

bool isNum(char ch)
{
    if(ch >= '0' && ch <= '9') return true;
    else return false;
}

bool isOperate(char ch)
{
    if(ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(' || ch == ')')
    return true;
    else return false;
}

int level(char ch)
{
    switch(ch)
    {
        case '(' :
            return 5;
        case '*' :
            return 4;
        case '/' :
            return 4;
        case '+' :
            return 3;
        case '-' :
            return 3;
        case ')':
            return 2;
    }
}

double scd(string s)
{
    if(s.length() == 0) return INT_MAX;

    bool flag = false;
    for(int i = 0; i < s.length(); i++)
    {
        if(i == 0 && s[i] == '-') continue;
        else if(s[i] == '.' && !flag)
        {
            if(i > 0 && isNum(s[i-1]))
            {
                flag = true;
                continue;
            }
            else return INT_MAX;
        }
        else if(isNum(s[i])) continue;
        else return INT_MAX;
    }

    double result = atof(s.c_str());
    return result;
}


vector<string> midToPost(string s)
{
    stack<char> S;
    vector<string> V;
    int i = 0;
    while(i < s.length())
    {
        if(isNum(s[i]))
        {
            string str = "";
            while(isNum(s[i]) || s[i] == '.')
            {
                str += s[i];
                i++;
            }
            V.push_back(str);
        }

        else if(isOperate(s[i]))
        {

            if(s[i] == '-' && (i == 0 || !isNum(s[i-1])))
            {
                string str = "-"; i++;
                while(isNum(s[i]) || s[i] == '.')
                {
                    str += s[i]; i++;
                }
                V.push_back(str);
            }
            else
            {
                if(S.empty())
                {
                    S.push(s[i]); i++;
                }
                else
                {
                    int initial = level(s[i]);
                    if(initial == 2)
                    {
                        while(level(S.top()) != 5 && !s.empty())
                        {
                            string str = "";
                            str += S.top();
                            V.push_back(str);
                            S.pop();
                        }
                        if(S.top() == '(') S.pop();
                        i++;
                    }


                    else
                    {
                        while(!S.empty() && initial <= level(S.top()) && level(S.top()) != 5)
                        {
                            string str = "";
                            str += S.top();
                            V.push_back(str);
                            S.pop();
                        }
                        S.push(s[i]); i++;
                    }
                }
            }
        }
        else
        {
            cout << "表达式出错" << endl;
            V.clear();
            return V;
        }
    }
    while(!S.empty())
    {
        string str = ""; str += S.top();
        S.pop();
        V.push_back(str);
    }
    //for(int i = 0; i < V.size(); i++) cout << V[i] << "[]";
    return V;
}


double getValue(vector<string> V)
{
    stack<double> S;
    for(int i = 0; i < V.size(); i++)
    {
        if(V[i].length() == 1 && isOperate(V[i][0]))
        {
            double a = 0, b = 0;
            if(!S.empty())
            {
                a = S.top();
                S.pop();
            }else return INT_MAX;

            if(!S.empty())
            {
                b = S.top();
                S.pop();
            }else return INT_MAX;

            switch(V[i][0])
            {
                case '+':
                    S.push(b+a);
                    break;
                case '-':
                    S.push(b-a);
                    break;
                case '*':
                    S.push(b*a);
                    break;
                case '/':
                    S.push(b/a);
                    break;
                default:
                    return INT_MAX;
            }
        }
        else
        {
            if(scd(V[i]) == INT_MAX) return INT_MAX;
            else S.push(scd(V[i]));
        }
    }
    if(S.empty()) return INT_MAX;

    double value = S.top();
    S.pop();
    return value;
}

calculator::~calculator()
{

}

运行结果：

点击C清除历史记录

以及报错处理

double scd(string s)
{
    if(s.length() == 0) return INT_MAX;

    bool flag = false;
    for(int i = 0; i < s.length(); i++)
    {
        if(i == 0 && s[i] == '-') continue;
        else if(s[i] == '.' && !flag)
        {
            if(i > 0 && isNum(s[i-1]))
            {
                flag = true;
                continue;
            }
            else return INT_MAX;
        }
        else if(isNum(s[i])) continue;
        else return INT_MAX;
    }

    double result = atof(s.c_str());
    return result;
}

这段代码实现的是将一个字符串转化为 double 类型的数值。函数的参数是一个字符串类型的变量 s，表示需要转化的字符串。

函数首先检查字符串长度是否为0，如果是，则返回一个最大值为 INT_MAX 的数值。

然后，函数遍历字符串中的每一个字符，做如下判断：

  1. 如果字符是负号并且是第一个字符，则跳过该字符，继续检查下一个字符。

  2. 如果字符是小数点并且之前没有出现过小数点，则继续检查下一个字符。

  3. 如果字符是数字，则继续检查下一个字符。

  4. 如果字符不是上述三种情况，则字符串中包含非法字符，返回一个最大值为 INT_MAX 的数值。

如果字符串中没有非法字符，则函数使用 atof 函数将字符串转化为 double 类型的数值，并返回这个数值。

vector<string> midToPost(string s)
{
    stack<char> S;
    vector<string> V;
    int i = 0;
    while(i < s.length())
    {
        if(isNum(s[i]))
        {
            string str = "";
            while(isNum(s[i]) || s[i] == '.')
            {
                str += s[i];
                i++;
            }
            V.push_back(str);
        }

        else if(isOperate(s[i]))
        {

            if(s[i] == '-' && (i == 0 || !isNum(s[i-1])))
            {
                string str = "-"; i++;
                while(isNum(s[i]) || s[i] == '.')
                {
                    str += s[i]; i++;
                }
                V.push_back(str);
            }
            else
            {
                if(S.empty())
                {
                    S.push(s[i]); i++;
                }
                else
                {
                    int initial = level(s[i]);
                    if(initial == 2)
                    {
                        while(level(S.top()) != 5 && !s.empty())
                        {
                            string str = "";
                            str += S.top();
                            V.push_back(str);
                            S.pop();
                        }
                        if(S.top() == '(') S.pop();
                        i++;
                    }


                    else
                    {
                        while(!S.empty() && initial <= level(S.top()) && level(S.top()) != 5)
                        {
                            string str = "";
                            str += S.top();
                            V.push_back(str);
                            S.pop();
                        }
                        S.push(s[i]); i++;
                    }
                }
            }
        }
        else
        {
            cout << "表达式出错" << endl;
            V.clear();
            return V;
        }
    }
    while(!S.empty())
    {
        string str = ""; str += S.top();
        S.pop();
        V.push_back(str);
    }
    //for(int i = 0; i < V.size(); i++) cout << V[i] << "[]";
    return V;
}

这段代码实现了将中缀表达式转换为后缀表达式的功能。函数接受一个字符串 s，其中包含中缀表达式，返回一个字符串数组 vector<string>，其中为转换后的后缀表达式。

  1. 遍历字符串 s，如果遇到数字，将数字及其可能的小数点连续取出，放入 vector<string> V 中，表示该数字。
  2. 如果遇到运算符号，分为如下情况处理： a. 如果当前运算符是负号 "-"，且它前面没有数字或者前面的字符不是数字或括号，则它是一个负数的符号，需要将其作为数字的一部分，连同负数后面的数字一起取出，放入 vector<string> V 中。 b. 如果当前运算符不是负号，需要考虑其与栈中已有运算符的优先级，如果栈顶运算符的优先级高于等于当前运算符，需要将栈顶运算符弹出，并放入 vector<string> V 中，直到栈顶元素优先级低于当前运算符或栈顶为左括号 "("，此时将当前运算符压入栈中。
  3. 如果遇到非数字和运算符的字符，说明表达式存在格式错误，直接返回空的 vector<string> V。
  4. 遍历结束后，如果栈中还有元素，需要将其弹出并放入 vector<string> V 中，得到最终的后缀表达式。

最后，程序返回 vector<string> V，其中包含转换后的后缀表达式。

double getValue(vector<string> V)
{
    stack<double> S;
    for(int i = 0; i < V.size(); i++)
    {
        if(V[i].length() == 1 && isOperate(V[i][0]))
        {
            double a = 0, b = 0;
            if(!S.empty())
            {
                a = S.top();
                S.pop();
            }else return INT_MAX;

            if(!S.empty())
            {
                b = S.top();
                S.pop();
            }else return INT_MAX;

            switch(V[i][0])
            {
                case '+':
                    S.push(b+a);
                    break;
                case '-':
                    S.push(b-a);
                    break;
                case '*':
                    S.push(b*a);
                    break;
                case '/':
                    S.push(b/a);
                    break;
                default:
                    return INT_MAX;
            }
        }
        else
        {
            if(scd(V[i]) == INT_MAX) return INT_MAX;
            else S.push(scd(V[i]));
        }
    }
    if(S.empty()) return INT_MAX;

    double value = S.top();
    S.pop();
    return value;
}

从左往右遍历后缀表达式，如果遇到运算符，则从栈中取出上一个操作数（先取出的是第二个操作数，后取出的是第一个操作数），进行运算，并将结果压入栈中；如果遇到数字，则将其转化为 double 类型并压入栈中。如果在遍历过程中栈为空，则说明表达式有错误，返回 INT_MAX。

其中，isOperate 函数用于判断一个字符是否为运算符；scd 函数用于将一个字符串转化为数字，如果无法转化则返回 INT_MAX。如果遇到未知的运算符，也返回 INT_MAX。

最后，如果栈中只有一个元素，则为计算结果。将其取出并返回。如果栈中有多个元素，则说明表达式有错误，返回 INT_MAX。

Augenstern.503
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
项目一：简单计算器的实现
weixin_51511895的博客
01-10 780
计算机软件技术实习项目一：简单计算器的实现
软件实习项目一：简单计算器的实现
qq_50944418的博客
12-06 760
软件实习项目一：简单计算器的实现 项目流程： （1） 实现图形化界面（添加计算器的按钮和用于显示输入数字、输出结果的区域等） （2） 设置计算器的一系列逻辑约束 （3） 完成中缀转后缀准备 （4） 实现带括号的混合运算功能
Java实战项目一：简易命令行计算器开发
howard2005的专栏
01-29 989
本次实战运用Java面向对象编程实现命令行计算器，通过Calculator类封装计算逻辑，UseCalculator类负责用户交互与结果输出。利用Scanner获取用户输入，根据运算符调用Calculator方法执行加减乘除操作，并采用try-catch处理异常，确保程序稳定运行及循环多次计算功能。
python简单计算器综合实验报告_项目一：简单计算器
weixin_39901213的博客
11-30 1935
实验报告2015/11/18步骤：1、将输入的string放入buffer中；2、将buffer中的字符按数字与符号以元组("int",'56')/("operator",'+)形式，依次存入tokens列表中，同时检查输入表达式的规范性，确保 "4+3-56"形式：规范：①可以以+-开头，但需在tokens中填充("int",'0');②不能连续输入两个符号，报错；③若以+-结尾，则在token...
实验项目一：计算器的设计和实现
u013518977的博客
12-03 2299
本文旨在记录“简单计算器的设计和实现”项目的开发过程。 设计的计算器实现的简单功能： 1. 能通过设计的按钮控件输入并实现简单算术运算，表达式在编辑框中显示，能将运算结果，输出在编辑框内显示； 2. 能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符； 3. 能够识别括号，优先级正确。并保存历史的表达式运算记录。
2022 最新 Android 基础教程，从开发入门到项目实战【b站动脑学院】学习笔记——实战一：简易计算器
weixin_43895667的博客
07-19 1461
2022 最新 Android 基础教程，从开发入门到项目实战【b站动脑学院】学习笔记——实战一：简易计算器
Python项目开发实战：如何实现简易计算器
一个好知识的传播者
04-29 707
Python作为一种简单易学且功能强大的编程语言，常被用于各类项目的开发。其中，开发简易计算器是一个很好的入门项目，它不仅可以锻炼我们的编程技能，还能让我们更好地理解变量、条件判断、函数等基本概念。本文将详细介绍如何使用Python实现一个简易计算器，包括需求分析、设计思路、代码实现以及测试与优化等方面。
Android 实战项目：简单计算器
热门推荐
梁辰兴的博客
10-28 1万+
本次主要介绍了App开发中常见简单控件的用法，包括：在文本视图上显示文本（设置文本的内容、大小和颜色）、修改视图的基本属性（设置视图的宽高、间距和对齐方式）、运用各种布局排列控件（线性布局、相对布局、网格布局、滚动视图）、处理按钮的触控事件（按钮控件的点击、长按、禁用与恢复）、在图像控件上显示图片（图像视图、图像按钮、同时展示文本与图像）。最后设计了一个实战项目“简单计算器”，在该项目的App编码中用到了前面介绍的大部分控件和布局，从而加深了对所学知识的理解。
【实验01 扩展实验】C#桌面项目：简易计算器
ruarua的成长之旅
03-18 872
（3）（选做）改进程序的设计，要求输入一个算术表达式，点击“=”按钮完成输入表达式的计算并输出（可以利用数据结构中的表达式计算原理，实现表达式的计算）。（2）计算方式：通过点击对应的按钮，输入第1个数（可以是整数或实数），输入运算符（+、-、*或/），再输入第2个数，点击“=”按钮，完成计算。（1）新建一个C#桌面项目Calc，实现简易计算器功能，界面如图1所示。不知道为什么录屏没给我录到头顶，将就看看。【Form1.cs代码】红色为每个按钮的方法名。
java项目：简单计算器实现（四则）
Wuweinan_190cm的博客
07-10 100
【代码】java项目：简单计算器实现（四则）
Kalku-Latorz：简单计算器
02-14
总的来说，"Kalku-Latorz：简单计算器"是一个很好的学习JavaScript基础和实践项目，它涵盖了网页开发中的基本概念，如用户交互、数据处理和页面动态更新。对于初学者来说，这是一个很好的起点，可以帮助他们理解如何...
Python项目案例源代码：tkinter计算器.zip
06-06
本项目案例是一个基于Tkinter的计算器，它能帮助我们深入理解如何使用Tkinter库构建功能完备的应用程序。 首先，我们需要了解Tkinter的基础知识。Tkinter是Python的标准GUI库，它基于Tcl/Tk，提供了一种跨平台的...
Calculator:简单计算器应用
03-20
本文将围绕标题为"Calculator:简单计算器应用"的项目进行详细阐述，主要关注其特征、实现技术和相关知识点。 首先，该计算器应用具备两种模式：普通计算器和科学计算器。普通计算器通常包含基本的加、减、乘、除等...
Calculator:简单计算器Android应用
05-12
这个名为"Calculator:简单计算器Android应用"的项目，旨在让Android开发人员了解如何构建一个功能基础但实用的计算器应用，同时也涉及到UI布局设计、按钮事件处理以及编程风格。 首先，让我们关注核心语言——Java...
SimpleCalculator:简单计算器
03-05
【标题】"SimpleCalculator:简单计算器"是一款基于Kotlin编程语言开发的应用程序，它提供基本的数学计算功能，包括加法、减法、乘法和除法。这款计算器旨在为用户提供一个轻量级且易于使用的界面，进行日常的数学...
【C++】C++中的find方法介绍
最新发布
qq_35902025的博客
07-25 408
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
背单词工具(C++)
zeyeqianli的博客
07-24 3437
【代码】背单词工具(C++)
C：图案打印
2401_85010100的博客
07-23 956
空心正方形，空心三角形，X形，沙漏图案打印
C++ //练习 15.28 定义一个存放Quote对象的vector，将Bulk_quote对象传入其中。计算vector中所有元素总的net_price。
Made in Code
07-25 622
C++ Primer（第5版） 练习 15.28
Java课程设计：简易计算器实现
"该资源是关于使用Java进行课程设计的一个项目，目的是开发一个简单的计算器程序，包含基础的四则运算、错误修正、历史记录查看以及登录注册功能。项目要求学生掌握Java语言，尤其是awt和swing库，使用Jdk和JCreator...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值