QT5 实现简易科学计算器

最新推荐文章于 2023-04-21 19:43:09 发布
最新推荐文章于 2023-04-21 19:43:09 发布
阅读量3.3k 收藏 60
点赞数 10
文章标签： c++ qt5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43518938/article/details/103761908
版权

QT5 实现简易科学计算器

界面展示

主界面
基础科学计算器界面
矩阵计算界面

功能叙述

              \;\;\;\;\;\;\, 基础计算界面允许加减乘除表达式计算及嵌套，以及一部分基本初等函数的数值计算，基本初等函数不允许嵌套函数及表达式，这个是此计算器的缺点
              \;\;\;\;\;\;\, 矩阵计算模块会实时根据行列输入生成对应表格，并给出行号和列号，并且第二个矩阵会根据第一个矩阵的行列自动创建，无需第二次输入行列数。缺点：作为右操作数的矩阵若不填满会导致程序异常终止，乘法的右操作数矩阵无法改变列数，时间仓促，待有时间进行修改

源码

主界面源码

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QDateTime>
#include <QTimer>
#include "matrixfunction.h"
#include "floatcanculator.h"

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

public slots:


    void timerUpdate(void);

signals:
    void showFloat();

private slots:

    void on_floatCanculate_clicked();

    void on_MatrixCalculate_clicked();

private:
    Ui::MainWindow *ui;

};
#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"


MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    FloatCanculator backFloat;
    connect(&backFloat , SIGNAL(FloatToMain()) , this , SLOT(ReveiveFloat()));

    QTimer *timer = new QTimer(this);
    connect(timer,SIGNAL(timeout()),this,SLOT(timerUpdate()));
    timer->start(1000);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_floatCanculate_clicked()
{
    FloatCanculator jump;
    jump.exec();
}
//void MainWindow::ReceiveFloat()
//{
//    this->show();
//}
void MainWindow::timerUpdate(void)
{
    QDateTime time = QDateTime::currentDateTime();
    QString str = time.toString("yyyy-MM-dd hh:mm:ss dddd");
    ui->Time->setText(str);
}

void MainWindow::on_MatrixCalculate_clicked()
{
    MatrixFunction jump;
    jump.exec();
}

基础计算界面

floatcanculator.h

#ifndef FLOATCANCULATOR_H
#define FLOATCANCULATOR_H

#include <QDialog>
#include <QLabel>
#include <QTimer>
#include <QDateTime>
#include <string>
#include "legalexpression.h"
#include "Function.h"
#include <QDebug>

using namespace std;

namespace Ui {
class FloatCanculator;
}

class FloatCanculator : public QDialog
{
    Q_OBJECT

public:
    explicit FloatCanculator(QWidget *parent = nullptr);
    ~FloatCanculator();
public slots:
    void timerUpdate(void);

private slots:
    void on_SinButton_clicked();

    void on_CosButton_clicked();

    void on_TanButton_clicked();

    void on_lnButton_clicked();

    void on_SevenButton_clicked();

    void on_FourButton_clicked();

    void on_OneButton_clicked();

    void on_EightButton_clicked();

    void on_FiveButton_clicked();

    void on_TwoButton_clicked();

    void on_ZeroButton_clicked();

    void on_NineButton_clicked();

    void on_SixButton_clicked();

    void on_ThreeButton_clicked();

    void on_DotButton_clicked();

    void on_DivisionButton_clicked();

    void on_MultiplyButton_clicked();

    void on_SubtractionButton_clicked();

    void on_PlusButton_clicked();

    void on_EqualButton_clicked();

    void on_ClearButton_clicked();

    void on_RightBracketButton_clicked();

    void on_LeftBrakerButton_clicked();

    void on_ExpButton_clicked();

    void on_DoubleZeroButton_clicked();

    void on_BackUpButton_clicked();

    void on_PowerButton_clicked();

    void on_SqrtButton_clicked();

    void on_LgButton_clicked();

    void on_FactorialButton_clicked();

signals:
    void FloatToMain();

private:
    Ui::FloatCanculator *ui;
    QLabel *Time;
    QLabel *LabelExpression;
    enum FunctionSituation{EMPTY = 0,POWER,SQRT,LG,FAC,SIN,COS,TAN,LN,EXP,NUM};
    int Flag;

    bool JudgeIllgalInput();
    void moveCursor();
};

#endif // FLOATCANCULATOR_H

floatcanculator.cpp

#include "floatcanculator.h"
#include "ui_floatcanculator.h"
#include "mainwindow.h"
#include "Beh.hpp"
#include "Expression.hpp"
#include "Stack.hpp"

FloatCanculator::FloatCanculator(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::FloatCanculator)
{
    ui->setupUi(this);
    Time = new QLabel(this);
    LabelExpression = new QLabel(this);

    QTimer *timer = new QTimer(this);
    connect(timer,SIGNAL(timeout()),this,SLOT(timerUpdate()));
    timer->start(1000);

    Flag = EMPTY;
}

FloatCanculator::~FloatCanculator()
{
    delete ui;
}

void FloatCanculator::timerUpdate()
{
    QDateTime time = QDateTime::currentDateTime();
    QString str = time.toString("yyyy-MM-dd hh:mm:ss dddd");
    Time->setText(str);
    Time->setAlignment(Qt::AlignLeft);
    Time->setGeometry(0,0,580,80);
    QFont font;
    font.setItalic(true);
    font.setPixelSize(30);
    Time->setFont(font);
    Time->show();
}
void FloatCanculator::on_SinButton_clicked()
{
    if(Flag != EMPTY)
        return;
    LabelExpression->clear();
    ui->Display->insert("sin()");
    if(JudgeIllgalInput())
    {
        Flag = SIN;
        moveCursor();
        ui->Display->setFocusPolicy(Qt::NoFocus);
    }
}

void FloatCanculator::on_CosButton_clicked()
{
    if(Flag != EMPTY)
        return;
    LabelExpression->clear();
    ui->Display->insert("cos()");
    JudgeIllgalInput();
    if(JudgeIllgalInput())
    {
        Flag = COS;
        moveCursor();
        ui->Display->setFocusPolicy(Qt::NoFocus);
    }
}

void FloatCanculator::on_TanButton_clicked()
{
    if(Flag != EMPTY)
        return;
    LabelExpression->clear();
    ui->Display->insert("tan()");
    if(JudgeIllgalInput())
    {
        Flag = TAN;
        moveCursor();
        ui->Display->setFocusPolicy(Qt::NoFocus);
    }
}

void FloatCanculator::on_lnButton_clicked()
{
    if(Flag != EMPTY)
        return;
    LabelExpression->clear();
    ui->Display->insert("ln()");
    if(JudgeIllgalInput())
    {
        Flag = LN;
        moveCursor();
        ui->Display->setFocusPolicy(Qt::NoFocus);
    }
}

void FloatCanculator::on_SevenButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("7");
}

void FloatCanculator::on_FourButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("4");
}

void FloatCanculator::on_OneButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("1");
}

void FloatCanculator::on_EightButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("8");
}

void FloatCanculator::on_FiveButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("5");
}

void FloatCanculator::on_TwoButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("2");
}

void FloatCanculator::on_ZeroButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("0");
}

void FloatCanculator::on_NineButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("9");
}

void FloatCanculator::on_SixButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("6");
}

void FloatCanculator::on_ThreeButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("3");
}

void FloatCanculator::on_DotButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert(".");
}

void FloatCanculator::on_DivisionButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("/");
}

void FloatCanculator::on_MultiplyButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("*");
}

void FloatCanculator::on_SubtractionButton_clicked()
{

    LabelExpression->clear();
    ui->Display->insert("-");
}

void FloatCanculator::on_PlusButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("+");
}

void FloatCanculator::on_EqualButton_clicked()
{
    double Answer = 0;
    LabelExpression->clear();
    // 按下等号获取当前QLineEdit中的字符串，并转化为string类型
    QString QExpression = ui->Display->text();
    string expressions = QExpression.toStdString();
    // 判断表达式是否合法
    LegalExpression Judger(expressions);
    if(Judger.isLegal())
    {
        if(Flag != EMPTY)
        {
            // 在这里直接进入函数泰勒计算
            // enum FunctionSituation{EMPTY = 0,POWER,SQRT,LG,FAC,SIN,COS,TAN,LN,EXP};
            switch (Flag)
            {
                case POWER:
                {
                    int Length = QExpression.length();
                    int position = QExpression.indexOf("∧");

                    QString QbaseNumber = QExpression;
                    QbaseNumber.chop(Length - position);
                    double baseNumber = QbaseNumber.toDouble();

                    QString QpowNumber = QExpression.mid(position+2);
                    QpowNumber.chop(1);
                    double powNumber = QpowNumber.toDouble();

                    Answer = getPow(baseNumber , powNumber);
                    break;
                }
                case SQRT:
                {
                    QString Qnumber = QExpression.mid(2);
                    Qnumber.chop(1);
                    double number = Qnumber.toDouble();

                    Answer = getSqrt(number);
                    break;
                }
                case LG:
                {
                    QString Qnumber = QExpression.mid(3);
                    Qnumber.chop(1);
                    double number = Qnumber.toDouble();

                    Answer = getLg(number);
                    break;
                }
                case FAC:
                {
                    QString Qnumber = QExpression;
                    Qnumber.chop(1);
                    double number = Qnumber.toDouble();

                    Answer = getFac(number);
                    break;
                }
                case SIN:
                {
                    QString Qnumber = QExpression.mid(4);
                    Qnumber.chop(1);
                    double number = Qnumber.toDouble();

                    Answer = getSin(number);
                    break;
                }
                case COS:
                {
                    QString Qnumber = QExpression.mid(4);
                    Qnumber.chop(1);
                    double number = Qnumber.toDouble();

                    Answer = getCos(number);
                    break;
                }
                case TAN:
                {
                    QString Qnumber = QExpression.mid(4);
                    Qnumber.chop(1);
                    double number = Qnumber.toDouble();

                    Answer = getTan(number);
                    break;
                }
                case LN:
                {
                    QString Qnumber = QExpression.mid(3);
                    Qnumber.chop(1);
                    double number = Qnumber.toDouble();

                    Answer = getLn(number);
                    break;
                }
                case EXP:
                {
                    QString Qnumber = QExpression.mid(4);
                    Qnumber.chop(1);
                    double number = Qnumber.toDouble();

                    Answer = getExp(number);
                    break;
                }
                default:
                    break;
            }
        }
        else
        {
            //接口留在这里，串联后端构建表达式以及输出表达式Q
            expressions += "#";
            Expression *get = strToTree( expressions );
            ui->Display->clear();
            Answer = getResult( get );             // 用这个参数接返回的计算值
        }


        QString QAnswer = QString::number(Answer , 10 , 6);
        ui->Display->setText(QAnswer);

        LabelExpression->setText(QExpression);
        LabelExpression->setAlignment(Qt::AlignRight);
        LabelExpression->setGeometry(581 , 0 , 580 , 80);

        QFont font;
        font.setPixelSize(30);

        LabelExpression->setFont(font);
        LabelExpression->show();
    }
    else
    {
        LabelExpression->setText("错误计算格式，请修改");
        LabelExpression->setAlignment(Qt::AlignRight);
        LabelExpression->setGeometry(581 , 0 , 580 , 80);

        QFont font;
        font.setPixelSize(30);

        LabelExpression->setFont(font);
        LabelExpression->show();
    }

}

void FloatCanculator::on_ClearButton_clicked()
{
    LabelExpression->clear();
    ui->Display->clear();
    Flag = EMPTY;
    ui->Display->setEnabled(true);
}

void FloatCanculator::on_RightBracketButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("(");
    JudgeIllgalInput();
    Flag = NUM;
}


void FloatCanculator::on_LeftBrakerButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert(")");
    Flag = NUM;
}

bool FloatCanculator::JudgeIllgalInput()
{
    bool ReturnJudge = true;


    QString expression = ui->Display->text();
    string stdExpression = expression.toStdString();
    //接口
    //返回值
    LegalExpression Judger(stdExpression);
    ReturnJudge = Judger.isLegal();
    if(!ReturnJudge)
    {
        LabelExpression->setText("错误计算格式，请修改");
        LabelExpression->setAlignment(Qt::AlignRight);
        LabelExpression->setGeometry(581 , 0 , 580 , 80);

        QFont font;
        font.setPixelSize(30);

        LabelExpression->setFont(font);
        LabelExpression->show();
    }
    return ReturnJudge;
}

void FloatCanculator::moveCursor()
{
    QString text = ui->Display->text();
    int position = text.indexOf(")");

    if(position != -1)
        ui->Display->setCursorPosition(position);
}

void FloatCanculator::on_ExpButton_clicked()
{
    if(Flag != EMPTY)
        return;
    LabelExpression->clear();
    ui->Display->insert("exp()");
    if(JudgeIllgalInput())
    {
        Flag = EXP;
        moveCursor();
        ui->Display->setFocusPolicy(Qt::NoFocus);
    }
}


void FloatCanculator::on_DoubleZeroButton_clicked()
{
    LabelExpression->clear();
    ui->Display->insert("00");
    JudgeIllgalInput();
    Flag = NUM;
}

void FloatCanculator::on_BackUpButton_clicked()
{
    QString text;
    text = ui->Display->text();

    int Length = text.length();
    text = text.mid(0,Length-1);
    ui->Display->setText(text);
    LabelExpression->clear();
    if(Flag != NUM)
        Flag = EMPTY;
    ui->Display->setEnabled(true);
}

void FloatCanculator::on_PowerButton_clicked()
{
    if(Flag != EMPTY)
        return;
    LabelExpression->clear();
    ui->Display->insert("∧()");

    QString text;
    text = ui->Display->text();

    QString preString = text;
    preString.chop(3);

    bool isNumber = true;
    double tempTest = preString.toDouble(&isNumber);

    if(!isNumber)
    {
        LabelExpression->setText("错误计算格式，请修改");
        LabelExpression->setAlignment(Qt::AlignRight);
        LabelExpression->setGeometry(581 , 0 , 580 , 80);

        QFont font;
        font.setPixelSize(30);

        LabelExpression->setFont(font);
        LabelExpression->show();
    }
    else
    {
        Flag = POWER;
        moveCursor();
        ui->Display->setFocusPolicy(Qt::NoFocus);
    }
}

void FloatCanculator::on_SqrtButton_clicked()
{
    if(Flag != EMPTY)
        return;
    LabelExpression->clear();
    ui->Display->insert("√()");

    QString text = ui->Display->text();

    if(text.at(0) != "√")
    {
        LabelExpression->setText("错误计算格式，请修改");
        LabelExpression->setAlignment(Qt::AlignRight);
        LabelExpression->setGeometry(581 , 0 , 580 , 80);

        QFont font;
        font.setPixelSize(30);

        LabelExpression->setFont(font);
        LabelExpression->show();
    }
    else
    {
        Flag = SQRT;
        moveCursor();
        ui->Display->setFocusPolicy(Qt::NoFocus);
    }
}

void FloatCanculator::on_LgButton_clicked()
{
    if(Flag != EMPTY)
        return;
    LabelExpression->clear();
    ui->Display->insert("lg()");

    QString text = ui->Display->text();

    if(text.at(1) != "g")
    {
        LabelExpression->setText("错误计算格式，请修改");
        LabelExpression->setAlignment(Qt::AlignRight);
        LabelExpression->setGeometry(581 , 0 , 580 , 80);

        QFont font;
        font.setPixelSize(30);

        LabelExpression->setFont(font);
        LabelExpression->show();
    }
    else
    {
        Flag = LG;
        moveCursor();
        ui->Display->setFocusPolicy(Qt::NoFocus);
    }
}

void FloatCanculator::on_FactorialButton_clicked()
{
    if(Flag != EMPTY)
        return;
    LabelExpression->clear();
    ui->Display->insert("!");

    QString text = ui->Display->text();

    QString preString = text;
    preString.chop(1);
    bool isNumber = true;

    double temp = preString.toDouble(&isNumber);

    if(!isNumber)
    {
        LabelExpression->setText("错误计算格式，请修改");
        LabelExpression->setAlignment(Qt::AlignRight);
        LabelExpression->setGeometry(581 , 0 , 580 , 80);

        QFont font;
        font.setPixelSize(30);

        LabelExpression->setFont(font);
        LabelExpression->show();
    }
    else
    {
        Flag = FAC;
        moveCursor();
        ui->Display->setFocusPolicy(Qt::NoFocus);
    }
}

Beh.hpp

#pragma once
#define _BEH_HPP_

#include <stdio.h>
#include <stdlib.h>
#include <string>

#include "Stack.hpp"
#include "Expression.hpp"

double strToDouble( std::string str, int n ) {
    double ret = 0.0; int dotMarker = 0;
    for ( int i = 0; i < n; i++ ) {
        if ( '.' == str[i] ) dotMarker = i;
        else {
            ret = ret * 10 + str[i] - '0';
        }
    }
    if ( 0 != dotMarker ) {
        for ( int i = 1; i < n - dotMarker; i++ ) {
            ret /= 10;
        }
    }
    return ret;
} // 字符串转数值，支持小数

char Prior[8][8] = { // 运算符优先级表 
	//      '+'  '-'  '*'  '/'  '('  ')'  '#'  '^'
	/*'+'*/ '>', '>', '<', '<', '<', '>', '>', '<', 
	/*'-'*/ '>', '>', '<', '<', '<', '>', '>', '<', 
	/*'*'*/ '>', '>', '>', '>', '<', '>', '>', '<', 
	/*'/'*/ '>', '>', '>', '>', '<', '>', '>', '<', 
	/*'('*/ '<', '<', '<', '<', '<', '=', ' ', '<', 
	/*')'*/ '>', '>', '>', '>', ' ', '>', '>', '>', 
	/*'#'*/ '<', '<', '<', '<', '<', ' ', '=', '<', 
	/*'^'*/ '>', '>', '>', '>', '<', '>', '>', '>' 
};

char getPrior( char prev, char curr ) {
    int i; int j; // 前一个操作已在栈中 // 当前运算符
    switch (prev) {
        case '+': i = 0; break;
        case '-': i = 1; break;
        case '*': i = 2; break;
        case '/': i = 3; break;
        case '(': i = 4; break;
        case ')': i = 5; break;
        case '#': i = 6; break;
        case '^': i = 7; break;
        default: break;
    }
    switch (curr) {
        case '+': j = 0; break;
        case '-': j = 1; break;
        case '*': j = 2; break;
        case '/': j = 3; break;
        case '(': j = 4; break;
        case ')': j = 5; break;
        case '#': j = 6; break;
        case '^': j = 7; break;
        default: break;
    }
    return Prior[i][j];
}

Expression* strToTree( std::string& str ) {
    Stack<char> optrStack; // 运算符栈
    Stack<Expression*> opndStack; // 运算数栈

    PushIntoStack( &optrStack, '#' ); // 先将#入栈，优先级最低，结尾必有#

    int i = 0;
    while ( i < str.length() ) {
        if ( str[i] >= '0' && str[i] <= '9' ) {
            std::string temp;
            while ( true ) {
                if ( !(str[i] >= '0' && str[i] <= '9') && str[i] != '.' ) {
                    break;
                }
                temp.push_back(str[i]);
                i++;
            }
            Expression* ptr = new Operand( strToDouble( temp, temp.length() ) );
            PushIntoStack( &opndStack, ptr );
        } // 为数字，建立叶子节点并暂存
        else {

            // 总原则
            // 高优先级的二叉树先建立：后入栈，先出栈
            // 低优先级的二叉树后建立：先入栈，后出栈
            // 栈顶元素 ： 当前元素

            switch (
                getPrior( DisplayTopItem( &optrStack ), str[i] )
            ) {
                case '<': {
                    PushIntoStack( &optrStack, str[i] );
                    i++;
                    break;
                }
                case '=': {
                    char temp;
                    PopFromStack( &optrStack, &temp );
                    i++;
                    break;
                } // 脱括号或者#
                case '>': {
                    char temp;
                    PopFromStack( &optrStack, &temp );
                    Expression* rptr; PopFromStack( &opndStack, &rptr );
                    Expression* lptr; PopFromStack( &opndStack, &lptr );
                    Expression* ptr = new Operator( lptr, rptr, temp );
                    PushIntoStack( &opndStack, ptr );
                    break;
                }
                default: break;
            }
        }
    }
    Expression* ptr;
    PopFromStack( &opndStack, &ptr );
    return ptr;
}

Expression.hpp

#pragma once
#define _EXPRESSION_HPP_

#include <stdio.h>
#include <stdlib.h>

class Expression {

public:
    Expression() {
        leftChild = rightChild = NULL;
    }
    Expression(
        Expression* theLeftChild, Expression* theRightChild
    ) {
        leftChild = theLeftChild;
        rightChild = theRightChild;
    } // 构造函数的重载

public:
    Expression* leftChild; Expression* rightChild;

};

class Operand : public Expression { // 操作数类 
    friend double getResult( Expression* ptr );
    friend void OutputInorder( Expression* out );

public:
    Operand( double value ) {
        leftChild = rightChild = NULL;
        this ->value = value;
    }

private:
    double value;

};

class Operator : public Expression { // 运算符类

    friend double getResult( Expression* ptr );
    friend void OutputInorder( Expression* out );

public:
    Operator(
        Expression* theLeftChild, Expression* theRightChild, char Type
    ) {
        leftChild = theLeftChild;
        rightChild = theRightChild;
        type = Type;
    } // 基类的指针实现多态

private:
    char type;
    
};

double getResult( Expression* ptr ) { // 对二叉树后序遍历
    double leftResult = 0, rightResult=0;
    
    if ( ptr ->leftChild )
        leftResult = getResult(ptr ->leftChild);
    else
        return ((Operand*)ptr) ->value;

    if ( ptr ->rightChild )
        rightResult = getResult(ptr ->rightChild);
    else
        return ((Operand*)ptr) ->value;

    switch (
        ((Operator*)ptr) ->type
    ) {
        case '+': return leftResult + rightResult;
        case '-': return leftResult - rightResult;
        case '*': return leftResult * rightResult;
        case '/': return leftResult / rightResult;
    }
    return 0;
}

void OutputInorder( Expression* out ) {
    if ( out ->leftChild )
        OutputInorder(out ->leftChild);
    else
        printf("%lf", ((Operand*)out) ->value);

    printf("%c", ((Operator*)out) ->type);

    if ( out ->rightChild )
        OutputInorder(out ->rightChild);
    else
        printf("%lf", ((Operand*)out) ->value);
}

Stack.hpp

#pragma once
#define _STACK_HPP_

#include <stdio.h>
#include <stdlib.h>

enum State {
    ERROR, COMPLETE
};

#define MAX_SIZE 100

template<typename T>
struct Stack {
    T dataStorage[MAX_SIZE];
    int topPtr = -1;
};

template<typename T>
int GetTopPtr( Stack<T>* ptr ) {
    return ptr ->topPtr;
}

template<typename T>
bool isFull( Stack<T>* ptr ) {
    bool ret = false;
    if ( MAX_SIZE - 1 == ptr ->topPtr ) ret = true;
    return ret;
}

template<typename T>
bool isEmpty( Stack<T>* ptr ) {
    bool ret = false;
    if ( -1 == ptr ->topPtr ) ret = true;
    return ret;
}

template<typename T>
State PushIntoStack( Stack<T>* ptr, T item ) {
    if ( MAX_SIZE - 1 == ptr ->topPtr ) {
        return State::ERROR;
    }
    else {
        (ptr ->dataStorage)[++ptr ->topPtr] = item;
        return State::COMPLETE;
    }
}

template<typename T>
State PopFromStack( Stack<T>* ptr, T* item ) {
    if ( -1 == ptr ->topPtr ) {
        return State::ERROR;
    }
    else {
        ptr ->topPtr --;
        *item = (ptr ->dataStorage)[ptr ->topPtr + 1];
        return State::COMPLETE;
    }
}

template<typename T>
T DisplayTopItem( Stack<T>* ptr ) {
    return (ptr ->dataStorage)[ptr ->topPtr];
}

Function.h

#ifndef FUNCTION_H
#define FUNCTION_H

#include <iostream>
#include <string>
#include <math.h>

using namespace std;

double getSin(double number);
double getCos(double number);
double getTan(double number);
double getLn(double number);
double getExp(double number);
double getPow(double baseNumber , double powNumber);
double getSqrt(double number);
double getLg(double number);
double getFac(double number);

#endif // FUNCTION_H

Function.cpp

#include "Function.h"

double getSin(double number)
{
    double answer = 0;
    // 弧度
    double radian = (number * 3.1415926) / 180.0;
    answer = sin(radian);

    return answer;
}

double getCos(double number)
{
    double answer = 0;
    // 弧度
    double radian = (number * 3.1415926) / 180.0;
    answer = cos(radian);

    return answer;
}

double getTan(double number)
{
    double answer = 0;
    // 弧度
    double radian = (number * 3.1415926) / 180.0;
    answer = tan(radian);

    return answer;
}

double getLn(double number)
{
    double answer = 0;

    answer = log(number);

    return answer;
}

double getExp(double number)
{
    double answer = 0;

    answer = exp(number);

    return answer;
}

double getSqrt(double number)
{
    double answer = 0;

    answer = sqrt(number);

    return answer;
}

double getLg(double number)
{
    double answer = 0;

    answer = log10(number);

    return answer;
}

double getFac(double number)
{
    double answer = 1;

    for (double i = 2; i <= number; ++i)
    {
        answer *= i;
    }

    return answer;
}

double getPow(double baseNumber, double powNumber)
{
    double answer = 0;

    answer = pow(baseNumber, powNumber);

    return answer;
}

legalexpression.h

#ifndef LEGAL_EXPRESSION_H
#define LEGAL_EXPRESSION_H

#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>

using namespace std;

#define INIT_STACK_SIZE 101

class LegalExpression
{

public:

    LegalExpression();
    LegalExpression(string expression);
    virtual ~LegalExpression();

    bool isLegal();		// 如果合法，返回true
    void Push(char in);
    void Pop(char& out);

    struct ExpressionStack
    {
        char* topPointer;
        char* basePointer;
        int stackSize;
    };

private:

    string expression;
    const char* c_expression = NULL;
    ExpressionStack stack;

};


#endif // !LEGAL_EXPRESSION_H

legalexpression.cpp

#include "LegalExpression.h"

LegalExpression::LegalExpression()
{
    c_expression = NULL;
}

LegalExpression::LegalExpression(string expression)
{
    this->expression = expression;
    c_expression = this->expression.c_str();
    // 初始化栈
    stack.basePointer = (char*)malloc(sizeof(char) * INIT_STACK_SIZE);
    if (!stack.basePointer)
        exit(OVERFLOW);
    stack.topPointer = stack.basePointer;

    stack.stackSize = INIT_STACK_SIZE;
}

LegalExpression::~LegalExpression()
{
    stack.topPointer = NULL;
    delete[] stack.basePointer;
}

bool LegalExpression::isLegal()
{
    bool ReturnJudge = true;

    int Length = expression.length();

    // 0为无操作正在等待，1为有特殊操作等待
    int Flag = 0;

    for (int i = 0; i < Length; ++i)
    {
        switch (Flag)
        {
            case 0:
            {
                if (c_expression[i] == ')')
                {
                    Flag = 1;
                    continue;
                }
                else if (c_expression[i] == 'l')
                {
                    Flag = 2;
                }
                else if (c_expression[i] == 's')
                {
                    Flag = 2;
                }
                else if (c_expression[i] == 'c')
                {
                    Flag = 2;
                }
                else if (c_expression[i] == 't')
                {
                    Flag = 2;
                }
                Push(c_expression[i]);
                break;
            }
            case 1:
            {
                char out;
                Pop(out);
                while (out != '(')
                {
                    Pop(out);
                }
                // 括号连续并且没有符号作为间隔
                if (c_expression[i] == '(')
                {
                    ReturnJudge = false;
                    return ReturnJudge;
                }
                else if (c_expression[i] >= 'a' && c_expression[i] <= 'z')
                {
                    ReturnJudge = false;
                    return ReturnJudge;
                }
                Push(c_expression[i]);
                break;
            }
            case 2:
            {
                if (c_expression[i] == ')')
                {
                    Flag = 3;
                    continue;
                }
                Push(c_expression[i]);
                break;
            }
            case 3:
            {
                char out;
                Pop(out);
                while (out != '(')
                {
                    Pop(out);
                }
                if (c_expression[i] >= 'a' && c_expression[i] <= 'z')
                {
                    ReturnJudge = false;
                    return ReturnJudge;
                }
                else if (c_expression[i] == '(')
                {
                    ReturnJudge = false;
                    return ReturnJudge;
                }
                Push(c_expression[i]);
                Flag = 2;
                break;
            }
            default:
                break;
        }
    }

    return ReturnJudge;
}

void LegalExpression::Push(char in)
{
    *stack.topPointer++ = in;
}

void LegalExpression::Pop(char& out)
{
    out = *--stack.topPointer;
}

矩阵计算界面

matrixfunction.h

#ifndef MATRIXFUNCTION_H
#define MATRIXFUNCTION_H

#include <QDialog>
#include <QTimer>
#include <QDateTime>
#include <QLabel>
#include <QHeaderView>

#define MAXROW 20
#define MAXCOLUMN 20

namespace Ui {
class MatrixFunction;
}

class MatrixFunction : public QDialog
{
    Q_OBJECT

public:
    explicit MatrixFunction(QWidget *parent = nullptr);
    ~MatrixFunction();

    typedef struct noname{
        double value[MAXROW][MAXCOLUMN];
        int row;
        int column;
    }QMatrix;

    QMatrix left;
    QMatrix right;
    QMatrix answer;


public slots:

    void timerUpdate(void);
    void makeTable();


private slots:

    void on_PlusButton_clicked();

    void on_SubstractButton_clicked();

    void on_MultiplyButton_clicked();

    void on_ClearButton_clicked();

    void on_EqualsButton_clicked();

private:
    Ui::MatrixFunction *ui;

    QLabel *Time;
    QLabel *LabelExpression;

    QTimer *timer;
    QTimer *readTimer;

    enum Function{EMPTY , PLUS , SUB , MUL};

    int Flag;

    void setWrongLabel(QString message);

    void getAdd();
    void getSub();
    void getMul();
};

#endif // MATRIXFUNCTION_H

matrixfunction.cpp

#include "matrixfunction.h"
#include "ui_matrixfunction.h"

MatrixFunction::MatrixFunction(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::MatrixFunction)
{
    ui->setupUi(this);

    Time = new QLabel(this);
    LabelExpression = new QLabel(this);

    timer = new QTimer(this);
    connect(timer,SIGNAL(timeout()),this,SLOT(timerUpdate()));
    timer->start(1000);

    readTimer = new QTimer(this);
    connect(readTimer , SIGNAL(timeout()) , this , SLOT(makeTable()));
    readTimer->start(1000);

    for(int i = 0 ; i < MAXROW ; ++i)
    {
        for(int j = 0 ; j < MAXCOLUMN ; ++j)
        {
            left.value[i][j] = 0;
            right.value[i][j] = 0;
            answer.value[i][j] = 0;
        }
    }
    left.row = right.row = answer.row =  0;
    left.column = right.column = answer.column = 0;

    Flag = EMPTY;
}

MatrixFunction::~MatrixFunction()
{
    delete ui;
}

void MatrixFunction::timerUpdate()
{
    QDateTime time = QDateTime::currentDateTime();
    QString str = time.toString("yyyy-MM-dd hh:mm:ss dddd");
    Time->setText(str);
    Time->setAlignment(Qt::AlignLeft);
    Time->setGeometry(0,0,580,80);
    QFont font;
    font.setItalic(true);
    font.setPixelSize(30);
    Time->setFont(font);
    Time->show();
}

void MatrixFunction::makeTable()
{
    LabelExpression->clear();
    int Row , Column;
    bool judgeRow = true , judgeColumn = true;
    Row = ui->RowMatrix->text().toInt(&judgeRow);
    Column = ui->ColumnMatrix->text().toInt(&judgeColumn);

    if(judgeRow && judgeColumn)
    {
        ui->Display->verticalHeader()->hide();
        ui->Display->horizontalHeader()->hide();
        ui->Display->setRowCount(Row+1);
        ui->Display->setColumnCount(Column+1);
        for(int i = 0 ; i < Row ; i++)
        {
            ui->Display->setItem(i+1,0,new QTableWidgetItem(QString::number(i+1 , 10)));
        }
        for(int i = 0 ; i < Column ; ++i)
        {
            ui->Display->setItem(0,i+1,new QTableWidgetItem(QString::number(i+1 , 10)));
        }

        for(int i = 0 ; i <= Row ; ++i)
            ui->Display->setRowHeight(i,50);
        for(int i = 0 ; i <= Column ; ++i)
            ui->Display->setColumnWidth(i,50);
    }
    else if(ui->RowMatrix->text() == NULL && ui->ColumnMatrix->text() == NULL)
    {
    }
    else
    {
        ui->Display->clear();
        setWrongLabel("错误行列数目格式，请修改");
    }


}

void MatrixFunction::setWrongLabel(QString message)
{
    LabelExpression->setText(message);
    LabelExpression->setAlignment(Qt::AlignRight);
    LabelExpression->setGeometry(581 , 0 , 580 , 80);

    QFont font;
    font.setPixelSize(30);

    LabelExpression->setFont(font);
    LabelExpression->show();
}

void MatrixFunction::MatrixFunction::getAdd()
{
    for(int i = 0 ; i <= answer.row ; ++i)
    {
        for(int j = 0 ; j <= answer.column ; ++j)
        {
            answer.value[i][j] = left.value[i][j] + right.value[i][j];
        }
    }
}

void MatrixFunction::getSub()
{
    for(int i = 0 ; i <= answer.row ; ++i)
    {
        for(int j = 0 ; j <= answer.column ; ++j)
        {
            answer.value[i][j] = left.value[i][j] - right.value[i][j];
        }
    }
}

void MatrixFunction::getMul()
{
    int limit = left.column;
    for(int i = 0 ; i <= answer.row ; ++i)
    {
        for(int j = 0 ; j <= answer.column ; ++j)
        {
            double sum = 0;
            for ( int k = 0; k <= limit; k++ )
            {
                sum += left.value[i][k] * right.value[k][j];
            }
            answer.value[i][j] = sum;
        }
    }
}

void MatrixFunction::on_PlusButton_clicked()
{
    readTimer->stop();
    int row = ui->RowMatrix->text().toInt();
    int column = ui->ColumnMatrix->text().toInt();
    bool Judge = true;              //true说明填满了

    for(int i = 1 ; i <= row ; ++i)
    {
        for(int j = 1 ; j <= column ; ++j)
        {
            if(ui->Display->item(i,j) == NULL || ui->Display->item(i,j)->text() == "")
            {
                Judge = false;
                break;
            }
            else
                left.value[i-1][j-1] = ui->Display->item(i,j)->text().toDouble();
        }
        if(!Judge)
            break;
    }
    if(Judge)
    {
        left.row = row-1;
        left.column = column-1;

        ui->Display->clear();

        makeTable();
        ui->RowMatrix->clear();
        ui->ColumnMatrix->clear();

        Flag = PLUS;
    }
    else
    {
        setWrongLabel("矩阵未写满，请填满后点击操作符");
    }

}

void MatrixFunction::on_SubstractButton_clicked()
{
    readTimer->stop();
    int row = ui->RowMatrix->text().toInt();
    int column = ui->ColumnMatrix->text().toInt();
    bool Judge = true;

    for(int i = 1 ; i <= row ; ++i)
    {
        for(int j = 1 ; j <= column ; ++j)
        {
            if(ui->Display->item(i,j) == NULL || ui->Display->item(i,j)->text() == "")
            {
                Judge = false;
                break;
            }
            else
                left.value[i-1][j-1] = ui->Display->item(i,j)->text().toDouble();
        }
        if(!Judge)
            break;
    }
    if(Judge)
    {
        left.row = row-1;
        left.column = column-1;

        ui->Display->clear();

        makeTable();
        ui->RowMatrix->clear();
        ui->ColumnMatrix->clear();

        Flag = SUB;
    }
    else
    {
        setWrongLabel("矩阵未写满，请填满后点击操作符");
    }
}

void MatrixFunction::on_MultiplyButton_clicked()
{
    readTimer->stop();
    int row = ui->RowMatrix->text().toInt();
    int column = ui->ColumnMatrix->text().toInt();
    bool Judge = true;

    for(int i = 1 ; i <= row ; ++i)
    {
        for(int j = 1 ; j <= column ; ++j)
        {
            if(ui->Display->item(i,j) == NULL || ui->Display->item(i,j)->text() == "")
            {
                Judge = false;
                break;
            }
            else
                left.value[i-1][j-1] = ui->Display->item(i,j)->text().toDouble();
        }
        if(!Judge)
            break;
    }
    if(Judge)
    {
        left.row = row-1;
        left.column = column-1;

        ui->Display->clear();

        LabelExpression->clear();
        int Row , Column;
        Column = ui->RowMatrix->text().toInt();
        Row = ui->ColumnMatrix->text().toInt();
        ui->Display->verticalHeader()->hide();
        ui->Display->horizontalHeader()->hide();
        ui->Display->setRowCount(Row+1);
        ui->Display->setColumnCount(Column+1);
        for(int i = 0 ; i < Row ; i++)
        {
            ui->Display->setItem(i+1,0,new QTableWidgetItem(QString::number(i+1 , 10)));
        }
        for(int i = 0 ; i < Column ; ++i)
        {
            ui->Display->setItem(0,i+1,new QTableWidgetItem(QString::number(i+1 , 10)));
        }
        for(int i = 0 ; i <= Row ; ++i)
            ui->Display->setRowHeight(i,50);
        for(int i = 0 ; i <= Column ; ++i)
            ui->Display->setColumnWidth(i,50);
        Flag = MUL;
    }
    else
    {
        setWrongLabel("矩阵未写满，请填满后点击操作符");
    }
}

void MatrixFunction::on_ClearButton_clicked()
{
    ui->Display->clear();
    ui->RowMatrix->clear();
    ui->ColumnMatrix->clear();

    for(int i = 0 ; i < left.row ; ++i)
    {
        for(int j = 0 ; j < left.column ; ++j)
        {
            left.value[i][j] = 0;
        }
    }

    left.row = 0;
    left.column = 0;

    for(int i = 0 ; i < right.row ; ++i)
    {
        for(int j = 0 ; j < right.column ; ++j)
        {
            right.value[i][j] = 0;
        }
    }

    right.row = 0;
    right.column = 0;

    for(int i = 0 ; i < answer.row ; ++i)
    {
        for(int j = 0 ; j < answer.column ; ++j)
        {
            answer.value[i][j] = 0;
        }
    }

    answer.row = 0;
    answer.column = 0;

    readTimer->start();
}

void MatrixFunction::on_EqualsButton_clicked()
{
    int row = 0;
    int column = 0;
    bool Judge = true;

    switch (Flag)
    {
        case EMPTY:
        {

            break;
        }
        case PLUS:
        {
            row = left.row+1;
            column = left.column+1;


            for(int i = 1 ; i <= row ; ++i)
            {
                for(int j = 1 ; j <= column ; j++)
                {
                    if(ui->Display->item(i,j) == NULL || ui->Display->item(i,j)->text() == "")
                    {
                        Judge = false;
                        break;
                    }
                    right.value[i-1][j-1] = ui->Display->item(i,j)->text().toDouble();
                }
                if(!Judge)
                    break;
            }
            if(Judge)
            {
                right.row = left.row;
                right.column = right.row;
                //在这里执行加法操作，结构体看.h文件，在public里面,返回值赋值给answer
                answer.row = left.row;
                answer.column = left.column;
                getAdd();
            }
            else
            {
                setWrongLabel("矩阵未写满，请填满后点击操作符");
            }
            break;
        }
        case MUL:
        {
            row = left.column+1;
            column = left.row+1;


            for(int i = 1 ; i <= row ; ++i)
            {
                for(int j = 1 ; j <= column ; j++)
                {
                    if(ui->Display->item(i,j) == NULL || ui->Display->item(i,j)->text() == "")
                    {
                        Judge = false;
                        break;
                    }
                    right.value[i-1][j-1] = ui->Display->item(i,j)->text().toDouble();
                }
                if(!Judge)
                    break;
            }
            if(Judge)
            {
                right.row = row;
                right.column = column;
                //在这里执行乘法操作，结构体看.h文件，在public里面,返回值赋值给answer
                answer.row = left.row;
                answer.column = left.row;
                getMul();
            }
            else
            {
                setWrongLabel("矩阵未写满，请填满后点击操作符");
            }
            break;
        }
        case SUB:
        {
            row = left.row+1;
            column = left.column+1;


            for(int i = 1 ; i <= row ; ++i)
            {
                for(int j = 1 ; j <= column ; j++)
                {
                    if(ui->Display->item(i,j) == NULL || ui->Display->item(i,j)->text() == "")
                    {
                        Judge = false;
                        break;
                    }
                    right.value[i-1][j-1] = ui->Display->item(i,j)->text().toDouble();
                }
                if(!Judge)
                    break;
            }
            if(Judge)
            {
                right.row = row;
                right.column = column;
                //在这里执行减法操作，结构体看.h文件，在public里面,返回值赋值给answer
                answer.row = left.row;
                answer.column = left.column;
                getSub();
            }
            else
            {
                setWrongLabel("矩阵未写满，请填满后点击操作符");
            }
            break;
        }
        default:
            break;
     }

    ui->Display->clear();
    row = answer.row+1;
    column = answer.column+1;
    ui->Display->verticalHeader()->hide();
    ui->Display->horizontalHeader()->hide();
    ui->Display->setRowCount(row+1);
    ui->Display->setColumnCount(column+1);
    for(int i = 0 ; i < row ; i++)
    {
        ui->Display->setItem(i+1,0,new QTableWidgetItem(QString::number(i+1 , 10)));
    }
    for(int i = 0 ; i < column ; ++i)
    {
        ui->Display->setItem(0,i+1,new QTableWidgetItem(QString::number(i+1 , 10)));
    }
    for(int i = 0 ; i < row ; ++i)
        ui->Display->setRowHeight(i,50);
    for(int i = 0 ; i < column ; ++i)
        ui->Display->setColumnWidth(i,50);

    for(int i = 0 ; i <= answer.row ; ++i)
    {
        for(int j = 0 ; j <= answer.column ; ++j)
        {
            ui->Display->setItem(i+1,j+1,new QTableWidgetItem(QString::number(answer.value[i][j])));
        }
    }
    readTimer->start();
}

main

#include "mainwindow.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}
新茶试火
关注
  • 10
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
用Qt实现科学计算器——完整代码
08-23
使用Qt实现了科学计算器，功能类似于Windows自带的计算器，附带了比较全面的代码注释，科学计算器的具体设计原理可以访问我博客https://mp.csdn.net/postedit/81952851
Qt计算器——功能完整的计算器
weixin_46061874的博客
06-07 1260
一、功能介绍参考windows 10系统自带的计算器，进一步完善实验1的计算器功能，基本要求（必须要具备的）： 支持四种计算模式：标准型、科学型、程序员、日期计算模式 ;支持货币与容量转换 ;支持不同模式的切换 。二、系统设计2.1概要设计2.2UI设计标准页面：货币转换界面：容量转换界面: 程序员计算器界面：容量转换界面：日期计算：科学计算器界面：实现代码：https://github.com/minsteps/calculator.........
基于QT的科学计算器
qq_44145934的博客
12-27 4048
基于Qt的科学计算器 本次科学计算的设计，我仿照win 10系统自带的科学计算器，完成相应的功能，能实现加减乘除，乘方开方，三角函数，二进制转换等功能。 在Qt4，Qt5版本下都可以运行。 效果图如下： 设计思路： 代码如下： /* Mainwindow.h文件*/ #ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QMainWindow> #include <QLineEdit> #include <QSyste
详解QT中的快速正弦、快速余弦函数的实现
Marc Pony
03-24 3697
文章目录一、问题描述二、推导过程1、推导过程 一、问题描述   数值计算中，许多数学函数(如正弦、余弦、平方根等)可以通过泰勒级数展开的方法求得，然而，对于正弦函数与余弦函数，采用泰勒级数展开的方法收敛速度慢，计算速度慢。那么，有没有在满足给定的计算精度前提下，快速计算正弦函数与余弦函数的算法呢？   QT中提供了快速正弦函数、快速余弦函数的算法，代码片段如下： #define QT_SINE_TABLE_SIZE 256 #define M_PI (3.14159265358979323846) inli
基于QT实现的计算器（只需要简单的栈知识，不仅仅是四则运算，接近手机内置计算器功能）
qq_42181309的博客
06-27 1375
参考文献：Qt 5.9 C++开发指南 (王维波等 著)及众多网上资料 1.问题定义及需求分析 课题目的： 由输入的四则算术表达式字符串，动态生成算术表达式所对应的后缀式，通过后缀式求值并输出； 输出的形式：界面上：以QT中的Text Browser进行输出结果。后台：通过suffix文件输出表达式的后缀表达式。 程序的功能：在布局和功能上，我们以小米内置计算器为标准。在运算上：我们实现...
基于qt5实现简易计算器
01-28
仿照win10计算器，基于qt5实现具有简单运算的计算器。 环境： QT 5.12.2+QT Creator 4.8.2+win10
基于QT软件实现简易计算器
最新发布
06-21
（1）使用QT软件实现简易计算器 （2）适用于想了解学习QT的学生，编程小白等 （3）QT是跨平台C++图形用户界面应用程序开发框架 （4）QT具有跨平台、面向对象、丰富的API、帮助文档丰富的特点， 1.跨平台。我们编写的...
Qt Creator实现简易计算器并封装
06-13
Qt Creator实现简易计算器并封装
C++ Qt图形界面实现简易计算器
04-22
数据结构实训的小项目，采用Qt编写图形界面，C++作为编写语言，实现简易的计算器。加减乘除，带括号的运算，以及容错处理，比如不能以运算符开头、两个运算符不能相邻等。
基于QT开发的线性代数初学者的矩阵计算器设计
毕业作品网站
06-26 1725
一、 题目一个适用于线性代数初学者的矩阵计算器开发软件Visual Studio 2019，Qt5.14.2，Qt VS Tools (version 2.7.1)课题要求面向对象。单元测试。模型部分验证主要流程开发流程及算法介绍从 0.0 版本到 4.0 版本均为在 VS 上编写好矩阵计算器计算部分的算法。版本为之前写过的两个独立程序（求逆、求有唯一解的线性方程组）版本完成了以下部分的计算代码：矩阵基本运算（加、减、乘），初等行变换（交换两行，将一行乘上某个实数，将一行的几倍加到另一行上）、求行列式，求逆
Qt5 科学计算器的实现
12-13
本项目使用了Qt5.3.2版本进行开发，使用了设计模式中的简单工厂设计模式，支持四则运算，三角函数运算和幂运算，是属于计算器中的科学计算型计算器
Qt版科学计算器
11-06
Qt编写的科学计算器，有良好的界面，部分功能未实现！
Qt实现简单计算器（整数）
07-08
该方法用qt来实现一个简单的计算器，内容包括界面的创建和计算的具体c++代码，设计qt独特的信号与槽机制，适合于新学习者来巩固qt的布局和信号与槽机制的练习
qt实现简易计算器
04-25
qt实现简易计算器，实现简单加减乘除，并可以实现乘除优先运算。
Qt正则表达式
m0_60259116的博客
04-21 199
Qt正则表达式
基于Qt实现的简易计算器（C++）
weixin_41477765的博客
04-23 5651
本人刚学Qt时实现了一个计算器的简单应用程序，刚好最近的程序设计训练有计算器这道题目，于是便完善了一下，拿出来分享给大家， 说不定有和我选一样的同学看到。 这是运行后的应用程序，由于我的电脑是Win7系统，所以我就参考Win7自带的应用计算器设计开发。 本程序参考《设计模式》将用户界面与业务逻辑分离开，并通过业务接口关联。 设计原则：功能模块之间需要进行解耦。 核心思想：强内聚，弱耦合...
QT中如何才能使用cos，sin等三角函数
热门推荐
尘埃飞舞
10-18 1万+
今天在写程序时候遇到一个问题，三角函数编辑出问题 #include <complex> 在win系统下，在QT中添加这个头文件以后，就可以使用三角函数，编译不会出错了 ...
Qt/C++实现多功能计算器
qq_41588862的博客
09-02 3882
一、界面布局 下面图片是计算器的界面布局。从界面可以得知计算器的基本功能，有加减乘除基本运算，还有余弦，正弦等函数运算。 二、功能简单介绍及运算展示 在以上运算中涉及了对数、指数、乘法和加法，乘法是在“25”与ln之间默认有一个乘号(在代码中有具体体现)。 功能介绍： 该计算器可以实现简单的加减乘除的运算以及带括号、带基本的三角函数、对数、指数的表达式的运算。 容错处理： 1.在文本框中输入表达式时，会自动检测表达是否正确，若即将输入的字符会导致表达式错误，则该字符不会被输入到文本框中，QVector

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值