项目一源代码

已于 2023-01-15 12:52:37 修改
阅读量83 收藏
点赞数
文章标签： qt ui
于 2023-01-07 09:51:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51368256/article/details/128587856
版权

1.calc_widget.h

#ifndef CALC_WIDGET_H
#define CALC_WIDGET_H

#include <QWidget>
#include<QStack>
#include<algorithm>
#include<stack>
#include<string>
#include<queue>
#include<QTextEdit>
#include<QTextLayout>
#include<QVector>
#include<QDebug>



QT_BEGIN_NAMESPACE
namespace Ui { class calc_Widget; }
QT_END_NAMESPACE

class calc_Widget : public QWidget
{
    Q_OBJECT

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

private slots:
    void on_one_button_clicked();


    void on_two_button_clicked();
    void on_three_button_clicked();
    void on_four_button_clicked();
    void on_five_button_clicked();
    void on_six_button_clicked();
    void on_seven_button_clicked();
    void on_eight_button_clicked();
    void on_nine_button_clicked();
    void on_zero_button_clicked();
    void on_point_button_clicked();
    void on_add_button_clicked();
    void on_sub_button_clicked();
    void on_mul_button_clicked();
    void on_div_button_clicked();
    void on_per_button_clicked();
    void on_left_button_clicked();
    void on_right_button_clicked();

//    void on_history_button_clicked();
    void on_clearall_button_clicked();
    void on_delete_button_clicked();
    void on_clear_button_clicked();
    void on_equal_button_clicked();




    void on_ans_button_clicked();


    void on_format_box_activated(int index);

    void on_rightmove_button_clicked();

    void on_leftmove_button_clicked();

    void on_esc_button_clicked();

    void on_pi_button_clicked();

    void on_e_button_clicked();

    void on_exp_button_clicked();

    void on_log_button_clicked();

    void on_up_button_clicked();

    void on_down_button_clicked();

    void on_rnd_box_activated(int index);

    void on_his_button_clicked();

private:
    Ui::calc_Widget *ui;
    QString expression;  //表示当前显示界面中的字符串
    QString dis_expression;
    QVector<QString> history_ans;
    static int expression_format;  //判断表达式格式
    QString inp(QString,int,QString);
    QString inp(QString,int);
    QString current_ans;


//    Qt::TextInteractionFlags textInteractionFlags() const;



};
#endif // CALC_WIDGET_H

2.calc_widget.cpp

#include "calc_widget.h"
#include "ui_calc_widget.h"
#include "calc_2.0.cpp"
#include"input_1.0.cpp"
using namespace std;




calc_Widget::calc_Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::calc_Widget)
{

    setFixedSize(525,605);
//
    ui->setupUi(this);
    ui->screen_lineedit->setEnabled(true);
    ui->screen_lineedit->setPlaceholderText("请选择输出格式");
    connect(ui->screen_lineedit,SIGNAL(returnPressed()),this,SLOT(on_equal_button_clicked()));
//    ui->mul_button->setText("×");
//    ui->div_button->setText("÷");
//    ui->pi_button->setText("π");



    this->setWindowTitle("卡细欧计算器");


    QFont fc("Times New Roman",20);
    QFont fh("Consolas",12);
//    ui->screen_lineedit->setFont(fc);           //设置主屏幕字体格式
//    ui->history_edit->setFont(fh);           //设置历史界面字体格式
//    setMaximumWidth(996);

    ui->history_edit->setReadOnly(true);   //设置历史只读
//    ui->gridLayout->SetFixedSize();

}

calc_Widget::~calc_Widget()
{
    delete ui;
}
int calc_Widget::expression_format=0;
int h_idx=0;

void calc_Widget::on_format_box_activated(int index)
{
    expression_format=index;
}
void calc_Widget::on_one_button_clicked()
{
    //    expression+="1";
   int pos=ui->screen_lineedit->cursorPosition();
   expression=inp(expression,pos,"1");
    ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_two_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"2");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_three_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"3");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_four_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"4");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_five_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"5");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_six_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"6");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_seven_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"7");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_eight_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"8");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_nine_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"9");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_zero_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"0");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_point_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,".");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_add_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"+");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_sub_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"-");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_mul_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"*");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_div_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"/");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_left_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"(");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_right_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,")");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_per_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"%");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}
void calc_Widget::on_delete_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos);
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos-1);
}
void calc_Widget::on_clear_button_clicked()
{
    expression.clear();
    ui->screen_lineedit->clear();
    h_idx=history_ans.size();
}
//void calc_Widget::on_history_button_clicked()
//{
//    QString h_ans;
//    for(auto ans:history_ans)
//    {
//        h_ans+=ans;
//        h_ans+="\t";
//    }
//    ui->screen_lineedit->setText(h_ans);
//}
void calc_Widget::on_clearall_button_clicked()
{
    expression.clear();
    history_ans.clear();
    ui->screen_lineedit->clear();
    ui->history_edit->clear();
    h_idx=0;
}
void calc_Widget::on_equal_button_clicked()
{
    if(expression.size()>0)
    {
        string experssion_sub=expression.toStdString();
        string dub_ans=calc(experssion_sub,expression_format);
        current_ans=QString::fromStdString(dub_ans);   //当前答案
        qDebug()<<current_ans;
        QString current_expersion=expression+"="+current_ans;            //历史展示整个式子
        history_ans.push_back(current_expersion);                             //存储历史
        ui->screen_lineedit->setText("= "+current_ans);
        expression=current_ans;                                        //当前值变为答案值
        ui->history_edit->append(current_expersion);
        h_idx=history_ans.size();
        qDebug()<<ui->screen_lineedit->cursorPosition();
    }
}

void calc_Widget::on_ans_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    if(expression!=current_ans)expression=inp(expression,pos,current_ans);
    ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+current_ans.size());
}


void calc_Widget::on_rightmove_button_clicked()
{
    ui->screen_lineedit->cursorForward(false,1);

}

void calc_Widget::on_leftmove_button_clicked()
{
    ui->screen_lineedit->cursorBackward(false,1);
}

void calc_Widget::on_esc_button_clicked()
{
    this->close();
}

void calc_Widget::on_pi_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"Pi");
     ui->screen_lineedit->setText(expression);
     ui->screen_lineedit->setCursorPosition(pos+2);

}

void calc_Widget::on_e_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"e");
     ui->screen_lineedit->setText(expression);
    ui->screen_lineedit->setCursorPosition(pos+1);
}

void calc_Widget::on_exp_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"^");
     ui->screen_lineedit->setText(expression);
     ui->screen_lineedit->setCursorPosition(pos+1);
}

void calc_Widget::on_log_button_clicked()
{
    int pos=ui->screen_lineedit->cursorPosition();
    expression=inp(expression,pos,"ln(");
     ui->screen_lineedit->setText(expression);
     ui->screen_lineedit->setCursorPosition(pos+3);
}
void calc_Widget::on_up_button_clicked()
{
    if(history_ans.empty());
    else if(h_idx>0)expression=history_ans[--h_idx],ui->screen_lineedit->setText(expression);
}

void calc_Widget::on_down_button_clicked()
{
    if(history_ans.empty());
    else if(h_idx<history_ans.size()-1)expression=history_ans[++h_idx],ui->screen_lineedit->setText(expression);
}

void calc_Widget::on_rnd_box_activated(int index)
{
    if(index)
    {
        int pos_index=index;
        int pos=ui->screen_lineedit->cursorPosition();
        srand(time(NULL));
        int t=1;
        while(index-->=1)t*=10;
        double rnd=rand()%(t);
        std::ostringstream os;
        os<<std::setprecision(3)<<rnd;
        expression=inp(expression,pos,QString::fromStdString(os.str()));
        ui->screen_lineedit->setText(expression);
        ui->screen_lineedit->setCursorPosition(pos+pos_index);
    }
}



void calc_Widget::on_his_button_clicked()
{
    ui->retranslateUi(this);
    if(this->width()==525)this->setFixedWidth(996);
    else this->setFixedWidth(525);
    ui->screen_lineedit->setText(expression);
//    qDebug()<<this->width();
}

3.cale_2.0.cpp

#include<algorithm>
#include<stack>
#include<string>
#include<queue>
#include<vector>
#include<QString>
#include<sstream>
#include<iomanip>
#include<cmath>
#include<QDebug>

using namespace std;


bool priority(string a,string b)  //a优先级是否大于等于b
{
    int a_n,b_n;

    if(a[0]-'+'==0||a[0]-'-'==0)a_n=0;
    if(b[0]-'+'==0||b[0]-'-'==0)b_n=0;
    if(a[0]-'*'==0||a[0]-'/'==0)a_n=1;
    if(b[0]-'*'==0||b[0]-'/'==0)b_n=1;
    if(a[0]-'l'==0)a_n=2;
    if(b[0]-'l'==0)b_n=2;
    if(a[0]-'^'==0)a_n=3;
    if(b[0]-'^'==0)b_n=3;
    if(a[0]-'('==0)return false;
    if(a_n>=b_n)return true;
    else return false;     //(
}
double oper(string a,double b,double c) //双目运算符计算
{
    if(a[0]-'.'==0){while(c>=1)c=c/10;return b+c;}
    else if(a[0]-'^'==0)
    {
        if(b==0&&c<=0)return 0x3f3f3f3f3f3f3f3f;
        else if(b<0&&(c<1||(int)c%2!=0))return 0x3f3f3f3f3f3f3f3f;
        else return pow(b,c);
    }
    else if(a[0]-'+'==0)return b+c;
    else if(a[0]-'-'==0)return b-c;
    else if(a[0]-'*'==0)return b*c;
    else if(a[0]-'/'==0&&c!=0)return b/c;
    else return 0x3f3f3f3f3f3f3f3f;   //a[0]-'/'==0&&c==0
}
double oper(double b,int t)// 计算符号% ln
{
    if(t==1)return b*0.01;
    else if(b<=0)return 0x3f3f3f3f3f3f3f3f;
    else return log(b);
}

//数字
void num(string c,queue<string> &operation)
{
    operation.push(c);
}

//四则运算
void four_ari(string c,queue<string> &operation,stack<string> &opertor)
{
    if(opertor.empty()){opertor.push(c);return;}
    if(priority(opertor.top(),c))
    /*比较栈顶和当前操作符，如果top>=current,top出栈操作符栈，入栈运算，将current和操作符栈元素比较，直到top < current，将current入栈操作符栈*/
    {
        while(!opertor.empty()&&priority(opertor.top(),c))
        {
            operation.push(opertor.top());
            opertor.pop();
        }
        opertor.push(c);
    }
    else opertor.push(c);//否则入栈
}


//右括号
void right(queue<string> &operation,stack<string> &opertor,int &brack)
{
    brack--;
    while(!opertor.empty()&&opertor.top()[0]-'('!=0)   //从栈顶开始将操作符元素全部入栈运算，直到遇到(
    operation.push(opertor.top()),opertor.pop();
    if(opertor.empty())brack=-2e9;
    else opertor.pop();//将左括号出栈
}

//左括号
void left(stack<string> &opertor,int &brack)
{
    opertor.push("(");
    brack++;
}
void exp(stack<string> &opertor)
{
    opertor.push("^");
}
//小数点
void point(string c,stack<string> &opertor,int &brack)
{

    left(opertor,brack);
    opertor.push(c);  //小数点优先级高于其他运算符，由于是双目，需要人为加对括号
}
void ln(stack<string>&opertor)
{
    opertor.push("ln");
}

//百分号
void per(queue<string> &operation)
{
    operation.push("%");
}

string calc(string expression,int expression_format)
{
    /*
   1 小数点后必须为数字
   2 百分号后可接右括号、四则运算符、百分号、指数
   3 左括号后可接数字和左右括号,负号,ln
   4 右括号后可接百分号，四则运算符，右括号,指数
   5 数字后可接四则运算符，百分号，小数点，右括号，数字、指数
   6 四则运算符后跟数字和左括号,ln
   7 指数后接数字和左括号,ln
   8 ln后接左括号
   */
    bool leg_input[8];
    memset(leg_input,true,sizeof leg_input);
    stack<int>dubln;  //调整ln顺序

    stack<string> opertor;
    queue<string> operation;
    int brack=0;   //判断括号是否成对
    unsigned long long idx=0;

    vector<string> pre_expression;//预处理表达式，将所有连续数字合并成一个字符串，操作符单独合并成一个字符串
    if(expression[0]-'0'<0||expression[0]-'0'>=10)
    {
        if(expression[0]-'('!=0&&expression[0]-'-'!=0&&expression[0]-'l'!=0&&expression[0]-'e'!=0&&expression[0]-'P'!=0)
            return "ERROR(INVALID INPUT_F)";
    }
    for(unsigned long long i=0;i<expression.size();i++)
    {
//        qDebug()<<expression[i];
        if(expression[i]-'e'==0)
        {
            pre_expression.push_back("2"),pre_expression.push_back("."),pre_expression.push_back("71828");
            continue;
        }
        if(expression[i]-'P'==0)
        {
            pre_expression.push_back("3"),pre_expression.push_back("."),pre_expression.push_back("14159"),i++;
            continue;
        }
        if(expression[i]-'0'<0||expression[i]-'0'>=10)//如果不是数字
        {
            string t;
            if(i==0&&expression[i]-'-'==0)pre_expression.push_back("0");
            if(expression[i]-'l'==0)
            {
                pre_expression.push_back("ln"),i++;
                continue;
            }
            t.push_back(expression[i]);
            pre_expression.push_back(t);
        }
        else
        {
            string n;
            int j=i;
            while(expression[j]-'0'>=0&&expression[j]-'0'<10)//从遇到数字开始，往后遍历直到不再为数字，将连续数字合并
                n.push_back(expression[j++]);
            if(i>0&&expression[i]-'0'==0&&expression[i-1]-'.'!=0&&n.size()>1)//前导0非法输入
                return "ERROR(INVALID INPUT_FZ)";
            if(i==0&&expression[0]-'0'==0&&n.size()>1)//首位前导0非法输入
                return "ERROR(INVALID INPUT_FZ)";
            pre_expression.push_back(n);
            i=j-1;
        }

    }
    if(pre_expression[0][0]-'('==0)
    {
        leg_input[2]=false;
        left(opertor,brack);
    }
    else if(pre_expression[0][0]-'l'==0)
    {
        leg_input[7]=false;
    }
    else
    {
        leg_input[4]=false;
        num(pre_expression[0],operation);
    }
    idx++;
    if(pre_expression.size()>2)
    {
        for(unsigned long long i=0;i<pre_expression.size()-2;i++)
        {
            if(pre_expression[i][0]-'.'==0&&pre_expression[i+2][0]-'.'==0)return "ERROR(INVALID INPUT_FP)";
        }
    }
    while(idx<pre_expression.size())
    {
        if(!leg_input[0])        //上个字符为小数点，下一个为数字
        {
            if(pre_expression[idx][0]-'0'>=0&&pre_expression[idx][0]-'0'<10)
            {
                leg_input[0]=true;
                leg_input[4]=false;
                num(pre_expression[idx++],operation);
                right(operation,opertor,brack);   //补上右括号
            }
            else return "ERROR(INVALID_INPUT_1)";
        }
        else if(!leg_input[1])   //上一个为百分号，下一个为右括号、四则运算符、百分号,指数
        {

            if(pre_expression[idx][0]-')'==0)//右括号
            {
                leg_input[1]=true;
                leg_input[3]=false;
                right(operation,opertor,brack);
                idx++;
                if(brack<0)return "ERROR(MISSING LEFT BRACKETS)2";
            }
            else if(pre_expression[idx][0]-'+'==0||pre_expression[idx][0]-'-'==0||pre_expression[idx][0]-'*'==0||pre_expression[idx][0]-'/'==0)
            {
                leg_input[1]=true;
                leg_input[5]=false;
                four_ari(pre_expression[idx++],operation,opertor);
            }
            else if(pre_expression[idx][0]-'^'==0)
            {
                leg_input[1]=true;
                leg_input[6]=false;
                exp(opertor);
                idx++;
            }
            else if(pre_expression[idx][0]-'%'==0)
            {
                per(operation);
                idx++;
            }
            else return "ERROR(INVALID_INPUT_2)";
        }
        else if(!leg_input[2])   //上个为左括号，下一个为数字和左右括号和负号
        {
            if(pre_expression[idx][0]-'0'>=0&&pre_expression[idx][0]-'0'<10)
            {
                leg_input[2]=true;
                leg_input[4]=false;
                num(pre_expression[idx++],operation);
            }
            else if(pre_expression[idx][0]-')'==0)
            {
                leg_input[2]=true;
                leg_input[3]=false;
                right(operation,opertor,brack);
                idx++;
                if(brack<0)return "ERROR(MISSING LEFT BRACKETS)3";
            }
            else if(pre_expression[idx][0]-'l'==0)
            {
                leg_input[2]=true;
                leg_input[7]=false;
                idx++;
            }
            //负号
            else if(pre_expression[idx][0]-'-'==0)
            {
                leg_input[2]=true;
                leg_input[5]=false;
                num("0",operation);   //负号前添0
                four_ari("-",operation,opertor);
                idx++;
            }

            else if(pre_expression[idx][0]-'('==0)
            {
                if(!dubln.empty())dubln.top()++;
                left(opertor,brack);
                idx++;
            }
            else return "ERROR(INVALID_INPUT_3)";
        }
        else if(!leg_input[3])   //上个为右括号，下一个为百分号，四则运算符，右括号
        {
            if(!dubln.empty())
            {
                dubln.top()--;
                if(dubln.top()==0)ln(opertor),dubln.pop();
            }

            if(pre_expression[idx][0]-'%'==0)
            {
                leg_input[3]=true;
                leg_input[1]=false;
                per(operation);
                idx++;
            }
            else if(pre_expression[idx][0]-'^'==0)
            {
                leg_input[3]=true;
                leg_input[6]=false;
                exp(opertor);
                idx++;
            }

            else if(pre_expression[idx][0]-'+'==0||pre_expression[idx][0]-'-'==0||pre_expression[idx][0]-'*'==0||pre_expression[idx][0]-'/'==0)
            {
                leg_input[3]=true;
                leg_input[5]=false;
                four_ari(pre_expression[idx++],operation,opertor);
            }

            else if(pre_expression[idx][0]-')'==0)
            {
                right(operation,opertor,brack);
                idx++;
                if(brack<0)return "ERROR(MISSING LEFT BRACKETS)4";
            }
            else return "ERROR(INVALID_INPUT_4)";
        }
        else if(!leg_input[4])   //上一位位数字，下一位四则运算符，百分号，小数点，右括号，数字，指数
        {
            //百分号
            if(pre_expression[idx][0]-'%'==0)
            {
                leg_input[4]=true;
                leg_input[1]=false;
                per(operation);
                idx++;
            }
            else if(pre_expression[idx][0]-'^'==0)
            {
                leg_input[4]=true;
                leg_input[6]=false;
                exp(opertor);
                idx++;
            }
            //四则运算符
            else if(pre_expression[idx][0]-'+'==0||pre_expression[idx][0]-'-'==0||pre_expression[idx][0]-'*'==0||pre_expression[idx][0]-'/'==0)
            {
                leg_input[4]=true;
                leg_input[5]=false;
                four_ari(pre_expression[idx++],operation,opertor);
            }
            //右括号
            else if(pre_expression[idx][0]-')'==0)
            {
                leg_input[4]=true;
                leg_input[3]=false;
                right(operation,opertor,brack);
                idx++;
                if(brack<0)return "ERROR(MISSING LEFT BRACKETS)5";
            }
            //小数点
            else if(pre_expression[idx][0]-'.'==0)
            {
                leg_input[4]=true;
                leg_input[0]=false;
                point(pre_expression[idx++],opertor,brack);
            }
//            //数字
//            else if(pre_expression[idx][0]-'0'>=0&&pre_expression[idx][0]-'0'<10)
//            {
//                num(pre_expression[idx++],operation);
//            }
            else return "ERROR(INVALID_INPUT_5)";
        }
        else if(!leg_input[5])   //上一个为四则运算符，下一位为数字和左括号
        {
             //数字
            if(pre_expression[idx][0]-'0'>=0&&pre_expression[idx][0]-'0'<10)
            {
                leg_input[5]=true;
                leg_input[4]=false;
                num(pre_expression[idx++],operation);
            }
            else if(pre_expression[idx][0]-'l'==0)
            {
                leg_input[5]=true;
                leg_input[7]=false;
                idx++;
            }
            //左括号
            else if(pre_expression[idx][0]-'('==0)
            {
                if(!dubln.empty())dubln.top()++;
                leg_input[5]=true;
                leg_input[2]=false;
                left(opertor,brack);
                idx++;
            }
            else return "ERROR(INVALID_INPUT_6)";
        }
        else if(!leg_input[6])   //上一个为指数，下一位为数字和左括号和负号
        {

             //数字
            if(pre_expression[idx][0]-'0'>=0&&pre_expression[idx][0]-'0'<10)
            {
                leg_input[6]=true;
                leg_input[4]=false;
                num(pre_expression[idx++],operation);
            }
            //左括号
            else if(pre_expression[idx][0]-'('==0)
            {
                if(!dubln.empty())dubln.top()++;
                leg_input[6]=true;
                leg_input[2]=false;
                left(opertor,brack);
                idx++;
            }
            else if(pre_expression[idx][0]-'l'==0)
            {
                leg_input[6]=true;
                leg_input[7]=false;
                idx++;
            }
            else return "ERROR(INVALID_INPUT_7)";
        }
        else if(!leg_input[7])   //上一个为ln，下一位为数字和左括号,ln
        {

            //左括号
            if(pre_expression[idx][0]-'('==0)
            {
                dubln.push(1);
                leg_input[7]=true;
                leg_input[2]=false;
                left(opertor,brack);
                idx++;
            }
            else return "ERROR(INVALID_INPUT_8)";
        }
    else return "ERROR(OTHER_ERROR)";

}
    if(brack>0)return "ERROR(MISSING RIGHT BRACKETS)";
    if(!dubln.empty()&&dubln.top()==1&&pre_expression[idx-1][0]-')'==0)
    {
        operation.push("ln");
        dubln.pop();
    }

    while(!opertor.empty())operation.push(opertor.top()),opertor.pop();//将剩余运算符入运算

//    while(!operation.empty()){cout<<operation.front()<<"#"<<endl;operation.pop();}
    //后缀表达式计算
    stack<double> ans;

    while(!operation.empty())
    {
        if(operation.front()[0]-'0'>=0&&operation.front()[0]-'0'<10)  //如果是数字，求出结果后入栈
        {
            double current_ans=0;
            for(unsigned long long i=0;i<operation.front().size();i++)
            {
                current_ans=current_ans*10+operation.front()[i]-'0';
            }
            if(operation.front()[0]-'0'==0)        //小数点后含有前导0
            {
                while(current_ans>=1)current_ans=current_ans/10;
                for(unsigned long long i=0;i<operation.front().size();i++)
                {
                    if(operation.front()[i]-'0'==0)current_ans=current_ans/10;
                    else break;
                }
            }
            ans.push(current_ans);
            operation.pop();
        }
        else if(!ans.empty()&&operation.front()[0]-'%'==0)
        {
            double res=ans.top();
            ans.pop();
            ans.push(oper(res,1));
            operation.pop();
        }
        else if(!ans.empty()&&operation.front()[0]-'l'==0)
        {
            double res=ans.top();
            ans.pop();
            ans.push(oper(res,0));
            if(ans.top()==0x3f3f3f3f3f3f3f3f)return "ERROR(MATH_ERROR)";
            operation.pop();
        }
        else if(ans.size()>=2)
        {
            double res_c=ans.top();
            ans.pop();
            double res_b=ans.top();
            ans.pop();
            ans.push(oper(operation.front(),res_b,res_c));
            if(ans.top()==0x3f3f3f3f3f3f3f3f)return "ERROR(MATH_ERROR)";
            operation.pop();
        }
        else return "ERROR(OUTPUT_ERROR_1)";

    }

    //结果输出
    if(ans.size()==1)
    {
//        char subans[32];
//        string ans_final=gcvt(ans.top(),16,subans);
        std::ostringstream ost;
        if(expression_format>=2)      //1 0.1 0.01 0.001
        {
            ost <<setiosflags(ios::fixed) << std::setprecision(expression_format-2) <<std::fixed<< ans.top();
            return ost.str();
        }
        else if(expression_format==1)   //science
        {
            int n=0;
            double anssc=ans.top();
            while(anssc>=10)anssc=anssc/10,n++;
            ost <<setiosflags(ios::fixed) << std::setprecision(4) <<std::fixed<<anssc;
            string ansc=ost.str()+"*10^"+to_string(n);
            return ansc;
        }
        else if(expression_format==0)  //NaN
        {
            ost << std::setprecision(12) <<ans.top();
            return ost.str();
        }

//        if(ans_final[ans_final.size()-1]-'.'==0)ans_final.erase(ans_final.size()-1,1);
        // return QString::fromStdString(ost.str());

    }
    else
    {
//        while(!ans.empty())cout<<ans.top()<<endl,ans.pop();
        return "ERROR(OUTPUT_ERROR_2)";
    }
}

4.input.cpp

#include<QString>
#include<algorithm>
#include<string>
#include<cstring>
#include<QDebug>
#include "calc_widget.h"
#include "ui_calc_widget.h"
//#include<iostream>
//#include<sstream>
//#include<iomanip>
using namespace std;

QString calc_Widget::inp(QString expression,int pos,QString s)
{
//    std::ostringstream ost;
//     ost <<std::setprecision(12) << pos;
//    return QString::fromStdString(ost.str());   //调试光标位置
    return expression.insert(min(pos,expression.size()),s);  //光标处插入

//    qDebug()<<ui->screen_lineedit->cursorPosition();

//    calc_Widget::on_leftmove_button_clicked();

}


QString calc_Widget::inp(QString expression,int pos)
{
    string t=expression.toStdString();
    if(pos>0)t.erase(min(pos-1,expression.size()-1),1);  //光标处删除
    return QString::fromStdString(t);
}

calc_widget.ui和main.cpp两个文件略。

麦克斯韦wwy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c#实验一源代码 使用软件VS
12-27
在C#编程中，"实验一源代码 使用软件VS" 提示我们这是关于使用Microsoft Visual Studio（VS）进行Windows应用程序开发的一个基础练习。Visual Studio是微软提供的一个集成开发环境（IDE），支持多种语言，包括C#，...
项目源代码。
01-12
解压缩后，直接打开就可以运行了。
开源集锦（二）项目源码
欢迎加入Android老司机学院 482266514（技术交流群）密码CSDN
04-30 1831
DateTimePicker https://github.com/CiTuX/datetimepicker BottomSheet https://github.com/soarcn/BottomSheet FilterMenu https://github.com/linroi
项目源代码
dhxiidjs的博客
10-23 141
成绩分析
如何阅读项目源代码
WantGoWorld的专栏
04-28 4583
如何读项目代码        当我们学习程序编码时，首先会看一些程序代码例子，然后学例子去修改编写代码；当我们刚进入一个公司，公司会把要维护修改的项目分给我们，让我们修改维护，要想修改编写，首先要读懂项目主要程序；当我们去看一些优秀的开源项目，想从中学习这些项目的设计思想时，我们也要去看项目代码…如此等等，可以说读代码是为了写代码，写出非常优秀的代码。因此对于程序开发人员来说，快速阅读项目
Vue实验一源代码：登陆界面
10-14
在"Vue实验一源代码：登陆界面"中，我们将探讨如何使用Vue.js构建一个简单的登录界面。在这个实验中，我们将关注以下几个核心知识点： 1. **Vue实例与模板**： - 在Vue中，我们首先需要创建一个Vue实例，它是Vue...
一源源码 全开源 springboot项目
最新发布
12-23
名称：《一源源码》 一源 = “天一生水”是中国古代哲学思想中的一句话，出自《易经》中的卦辞。它是描述宇宙生成和变化的原理，代表我们对代码无穷无尽的热爱。 我们是谁：我们是一群热爱编码和学习的开发者，有...
JavaCode:java核心技术卷一源代码-代
03-24
《JavaCode: Java核心技术卷一源代码》是一个与Java编程相关的资源，主要涵盖了Java语言的基础和核心概念。这个压缩包中的"JavaCode-master"很可能是一个包含源代码的项目目录，通常用于教学或学习目的，帮助开发者...
c代码-变量需先声明
07-16
这个文件通常是项目或代码库的说明文档，可能包含关于`main.c`的详细信息，如变量的用途、程序功能、编译和运行指令等。 综上所述，"变量需先声明"这一规则是C语言编程的基础，理解并遵循这一规则有助于编写清晰、...
java项目源码
11-27
开发者突击的整套源码，包含jsp、struts、struts2、spring、hibernate、ssh、ssh2
java 完整项目 源代码
04-19
java 源码 完整的项目 自己写的项目，已经验证，已经优化！
C++项目源代码（适合新手练手及参考）
07-04
适合刚涉及C++的新手练手，有源代码（注释详细），答辩PPT。
新闻网站项目源代码
11-10
本系统是一个功能完善的新闻类网站，由客户前台新闻浏览和后台新闻管理两大部分组成。前台功能模块：前台主要包括新闻分类、新闻详细信息、新闻信息查询、新闻搜索、信息公告查询、信息导读查询及提供后台登录口等。 后台管理模块：后台主要包括后台总管理员设置及密码修改、添加管理员、管理员信息设置、新闻类型管理、信息公告管理、焦点导读管理及退出后台等。
开源中国项目源代码
05-13
开源中国的android项目源代码，比较好的开源项目，可以下载下来学习一下。封装的还是比较好的。适合度过初学者的人进阶。
如何查找项目的源代码
LIWEI940638093的博客
01-29 7241
如何查找项目的源代码前言一 github二 CSDN三 博客园二 前言 平时科研中，为了解决某个问题，我们需要写大量的代码，有的动辄上千行，自己编写显然不太现实。那么怎么在网上找到我们所需要的源代码呢？ 一 github 进入首页 在搜索框中输入要搜索的内容 随便点进去一个搜索结果看一下 上半部分是代码，下半部分是代码的说明 如果觉得代码可以的话，可以直接下载代码：下载下来是一个zip格式的压缩包 搜索时的技巧：筛选规则 选择特定的编程语言：比如python 找精品的项目：搜索时添加“Awesom
华工微机与接口实验代码及调试过程
07-20
本文档Record了华工微机与接口实验的代码及调试过程，涵盖了数码转码编程、BCD 码转换为二进制码等多个实验项目，展示了微机实验的详细过程和调试结果。 一、数码转码编程 在实验二第一题中，要求将 ASCII 码表示...
《Visual C++ 6.0实例教程》源代码.rar
08-30
《Visual C++ 6.0实例教程》源代码rar压缩包包含了学习Visual ...在实际项目中，你可以参考这些实例来解决类似问题，提高编程效率。同时，源代码阅读也是提升编程能力的有效方式，能够帮助你更好地理解和运用编程技术。
详解Springboot+React项目跨域访问问题
08-26
例如，如果你的React应用运行在`http://localhost:3000`，试图通过Ajax请求访问运行在`http://localhost:8080`的Springboot服务，浏览器会阻止这种请求，因为它们不在同一源上。这称为跨域，是浏览器为了防止跨站...
XX市智慧环保项目建设方案概览
移动数据查询平台使得环保信息可以随时随地获取，如‘一源一档’移动查询、在线监控查询、环境质量数据查询等，方便了工作人员和公众的使用。同时，法规查询和应急响应系统进一步提升了环保管理的及时性和合法性。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值