精华内容
下载资源
问答
  • Qt自带的 QString 似乎没有现成的 API 判断字符串是否数字,于是想到利用正则进行判断。下面是方法。 实现方法 // 思路先判断字母情况,然后再判断包含正负小数情况 bool ret1 = item->text().contains...
    文章目录[隐藏]

    前言

    Qt自带的 QString 似乎没有现成的 API 判断字符串是否是数字,于是想到利用正则进行判断。下面是方法。

    实现方法

    // 思路先判断字母情况,然后再判断包含正负小数情况
    bool ret1 = item->text().contains(QRegExp("[A-Za-z]/g")) ? true : false; // 判断是否包含字母
    if(ret1)
    {
    	
    	QMessageBox::warning(NULL, QStringLiteral("提示"), QStringLiteral("不能含有字母"),
    						 QMessageBox::NoButton, QMessageBox::Yes);
    	return;
    }
    else
    {
    	if(!item->text().contains(QRegExp("[+-]?(0|([1-9]\\d*))(\\.\\d+)?")))
    	{
    		
    		QMessageBox::warning(NULL, QStringLiteral("提示"), QStringLiteral("请输入数字"),
    							 QMessageBox::NoButton, QMessageBox::Yes);
    		return;
    	}
    }
    
    展开全文
  • 判断字符串是否是整数浮点数的方法有几种方式,下面分别介绍: 1.用JAVA自带的函数,判断是否为整数 public static boolean isNumeric(String str) { for (int i = 0; i < str.length(); i++) ...

     

    判断字符串中是否是整数和浮点数的方法有几种方式,下面分别介绍:

     

     

    1.用JAVA自带的函数,判断是否为整数

     

     

    	public static boolean isNumeric(String str) {
    		for (int i = 0; i < str.length(); i++) {
    			System.out.println(str.charAt(i));
    			if (!Character.isDigit(str.charAt(i))) {
    				return false;
    			}
    		}
    		return true;
    	}

     

     

     

     

     

    2.用正则表达式,判断是否为整数

    首先要导入:import java.util.regex.Pattern 和 java.util.regex.Matcher

     

    public boolean isNumeric(String str){ 
       Pattern pattern = Pattern.compile("[0-9]*"); 
       Matcher isNum = pattern.matcher(str);
       if( !isNum.matches() ){
           return false; 
       } 
       return true; 
    }


    3.用正则表达式的方式,判断是否为数字,包括整数和小数

     

     

    	/**
    	 * 判断字符串是否为数字
    	 * 
    	 * @param str
    	 * @return
    	 */
    	public static boolean isNumeric(String str) {
    		Pattern pattern = Pattern.compile("[0-9]*\\.?[0-9]+");
    		Matcher isNum = pattern.matcher(str);
    		if (!isNum.matches()) {
    			return false;
    		}
    		return true;
    	}

    备注:3代码中原来的正则是:-?[0-9]+.?[0-9]+ , 小伙伴指出有bug,已经修复!

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 正则表达式: "-?(([1-9]\\d*\\.\\d*)|(0\\.\\d*[1-9]\\d*)|([1-9]\\d*))" QString data = "12.31 next 37.21"; QRegExp rx("-?... // 上一个匹配的字符串的长度 } qDebug() ; qDebug() ; 输出结果

     正则表达式: "-?(([1-9]\\d*\\.\\d*)|(0\\.\\d*[1-9]\\d*)|([1-9]\\d*))"

        QString data = "12.31 next 37.21";
        QRegExp rx("-?(([1-9]\\d*\\.\\d*)|(0\\.\\d*[1-9]\\d*)|([1-9]\\d*))");
        int p = 0;
        qDebug() << "begin";
        QStringList data_list;
        while ((p = rx.indexIn(data, p)) != -1)
        {
            data_list.append(rx.cap(1));
            p += rx.matchedLength(); // 上一个匹配的字符串的长度
    
        }
        qDebug() << data_list;
        qDebug() << "end";

    输出结果

    展开全文
  • QT 计算器练习(字符串运算)

    千次阅读 2018-05-17 18:45:24
    QT 计算器练习(字符串运算) 一、简述  记-计算器练习。字符串的"加减乘除"操作。  例子打包:链接: https://pan.baidu.com/s/1BjP-tmu5bafJv_ibxlXObg 提取码: k1m6   基本实现功能:  1、字符...

    QT 计算器练习(字符串运算)

    一、简述

        记-计算器练习。字符串的"加减乘除"操作。

         例子打包:链接: https://pan.baidu.com/s/1BjP-tmu5bafJv_ibxlXObg 提取码: k1m6 

        基本实现功能:

        1、字符串加法、减法、乘法、除法(模拟笔算),幂运算(x的y次方)、阶乘运算。(实现大数的四则运算)

        2、四则运算表达式的计算

        3、组合运算(计算所有种数、输出所有组合)

        4、表达式的合法性检测:括号是否匹配、对输入进行一定的合法检测

    注:没有实现小数运算、计算时会去掉小数点

    二、效果

    1、界面

    2、加减乘除运算

    3、组合、表达式、幂、阶乘运算

    三、工程结构图

    四、源文件

    Calculator.pro文件

    QT += widgets gui
    
    HEADERS += \
        calculator.h \
        exp.h \
        getcombine.h \
        getdiv.h \
        getjiecheng.h \
        getmlt.h \
        getpow.h \
        getsub.h \
        getsum.h
    
    SOURCES += \
        calculator.cpp \
        main.cpp \
        exp.cpp \
        getCombine.cpp \
        getDiv.cpp \
        getJieCheng.cpp \
        getMlt.cpp \
        getSub.cpp \
        getSum.cpp \
        getPow.cpp

    calculator.h文件

    #ifndef CALCULATOR_H
    #define CALCULATOR_H
    
    #include <QDialog>
    #include <QGridLayout>
    #include <QPushButton>
    #include <QTextBrowser>
    #include <QLabel>
    #include "exp.h"
    #include "getpow.h"
    #include "getjiecheng.h"
    #include "getcombine.h"
    
    class Calculator : public QDialog
    {
        Q_OBJECT
    public:
        explicit Calculator(QWidget *parent = 0);
    
    signals:
    
    public slots:
        void lBtnClick();//左括号'('
        void rBtnClick();//右括号')'
        void miBtnClick();//幂'^'
        void jcBtnClick();//阶乘"n!"
        void zhBtnClick();//组合"nCm"
    
        void qiBtnClick();//'7'
        void baBtnClick();//'8'
        void jiuBtnClick();//'9'
        void divBtnClick();//除'/'
        void clearBtnClick();//重置resLbl,'C'
    
        void siBtnClick();//'4'
        void wuBtnClick();//'5'
        void liuBtnClick();//'6'
        void mltBtnClick();//乘'*'
        void delBtnClick();//退格,"DEL"
    
        void yiBtnClick();//'1'
        void erBtnClick();//'2'
        void sanBtnClick();//'3'
        void subBtnClick();//减'-'
        void zeroBtnClick();//'0'
    
        void dotBtnClick();//点'.'
        void plusBtnClick();//加'+'
        void resBtnClick();//计算结果'='
        bool IsValid(QString);//表达式合法性检测
        bool IsMatch(QString);//判断表达式是否匹配
    private:
        QTextBrowser* _allResBrws;//展示表达式及所有结果
        QLabel *_resLbl;//创建一个标签,显示用户输入的表达式,计算后展示结果。
    };
    
    #endif // CALCULATOR_H

    exp.h文件

    #ifndef EXP_H
    #define EXP_H
    #include <QChar>
    #include <QDebug>
    #include <QVector>
    #include <getmlt.h>
    #include <getdiv.h>
    #include <getsub.h>
    #include <getsum.h>
    //函数声明部分
    int LeftPri(QChar op);//求左运算符op的优先级
    int RightPri(QChar op);//求右运算符op的优先级
    int IsOp(QChar ch);//判断ch是否是运算符
    int JudgePri(QChar lop, QChar rop); //判断左右运算符的优先级
    QString CountExp(QString exp);//计算表达式
    void Count(QChar op);//*/+-运算
    #endif // EXP_H

    getcombine.h文件

    #ifndef GETCOMBINE_H
    #define GETCOMBINE_H
        QString GetCombine(QString str1,QString str2,QString& res);
    #endif // GETCOMBINE_H

    getdiv.h文件

    #ifndef GETDIV_H
    #define GETDIV_H
        QString GetDiv(QString,QString);
        int CmpStr(QString str1,QString str2);//比较数字字符串的大小
    #endif // GETDIV_H

    getjiecheng.h文件

    #include <QString>
    #ifndef GETJIECHENG_H
    #define GETJIECHENG_H
    
    #include "getmlt.h"
    #include "getsub.h"
    #include <QString>
    QString GetJieCheng(QString str);
    #endif // GETJIECHENG_H

    getmlt.h文件

    #ifndef GETMLT_H
    #define GETMLT_H
    
    #include <QString>
    #include <getsub.h>
    #include <stdlib.h>
        int CmpStr(QString str1,QString str2);
        QString GetMlt(QString str1,QString str2);
    #endif // GETMLT_H

    getpow.h文件

    #ifndef GETPOW_H
    #define GETPOW_H
    
    #include <QString>
    #include <getsub.h>
    #include <getmlt.h>
        QString GetPow(QString,QString);
    #endif // GETPOW_H

    getsub.h文件

    #ifndef GETSUB_H
    #define GETSUB_H
    #include <QString>
    #include <stdlib.h>
    #include <getsum.h>
        QString GetSub(QString,QString);
    #endif // GETSUB_H

    getsum.h文件

    #ifndef GETSUM_H
    #define GETSUM_H
    
    #include <QString>
    #include <stdlib.h>
        QString GetSum(QString,QString);
    #endif // GETSUM_H

    calculator.cpp文件

    #include "calculator.h"
    
    Calculator::Calculator(QWidget *parent) :
        QDialog(parent)
    {
        if(1)
        {
        //创建一个网格布局
        QGridLayout *glay = new QGridLayout(this);
        //创建一个QTextBrowser,展示计算表达式与所有结果
        _allResBrws = new QTextBrowser;
        //设置固定高度
        _allResBrws->setFixedHeight(51);
    
        //创建一个标签,显示用户输入的表达式、计算结束后展示计算结果,初始文本为'0'
        _resLbl = new QLabel("0");
        //设置固定高度
        _resLbl->setFixedHeight(21);
        //设置标签样式
        _resLbl->setFrameShape(QFrame::StyledPanel);
        //设置从右向左展示文本
        _resLbl->setAlignment(Qt::AlignRight);
    
        //创建数字按钮以及运算符按钮
        QPushButton *lBtn = new QPushButton("(");
        QPushButton *rBtn = new QPushButton(")");
        QPushButton *miBtn = new QPushButton("^");
        QPushButton *jcBtn = new QPushButton("n!");
        QPushButton *zhBtn = new QPushButton("nCm");
    
        QPushButton *qiBtn = new QPushButton("7");
        QPushButton *baBtn = new QPushButton("8");
        QPushButton *jiuBtn = new QPushButton("9");
        QPushButton *divBtn = new QPushButton("/");
        QPushButton *clearBtn = new QPushButton("C");
    
        QPushButton *siBtn = new QPushButton("4");
        QPushButton *wuBtn = new QPushButton("5");
        QPushButton *liuBtn = new QPushButton("6");
        QPushButton *mltBtn = new QPushButton("*");
        QPushButton *delBtn = new QPushButton("DEL");
    
        QPushButton *yiBtn = new QPushButton("1");
        QPushButton *erBtn = new QPushButton("2");
        QPushButton *sanBtn = new QPushButton("3");
        QPushButton *subBtn = new QPushButton("-");
        QPushButton *zeroBtn = new QPushButton("0");
    
        QPushButton *dotBtn = new QPushButton(".");
        QPushButton *plusBtn = new QPushButton("+");
        QPushButton *resBtn = new QPushButton("=");
    
        //设置固定的高度
        resBtn->setFixedHeight(51);
        //将控件添加到窗体的网格布局
        glay->addWidget(_allResBrws,0,0,2,5);//将allResBrws添加到第0行第0列,占据2行,5列
        glay->addWidget(_resLbl,2,0,1,5);//将resLbl添加到第2行第0列,占据1行,5列
    
        glay->addWidget(lBtn,3,0,1,1);
        glay->addWidget(rBtn,3,1,1,1);
        glay->addWidget(miBtn,3,2,1,1);
        glay->addWidget(jcBtn,3,3,1,1);
        glay->addWidget(zhBtn,3,4,1,1);
    
        glay->addWidget(qiBtn,4,0,1,1);
        glay->addWidget(baBtn,4,1,1,1);
        glay->addWidget(jiuBtn,4,2,1,1);
        glay->addWidget(divBtn,4,3,1,1);
        glay->addWidget(clearBtn,4,4,1,1);
    
        glay->addWidget(siBtn,5,0,1,1);
        glay->addWidget(wuBtn,5,1,1,1);
        glay->addWidget(liuBtn,5,2,1,1);
        glay->addWidget(mltBtn,5,3,1,1);
        glay->addWidget(delBtn,5,4,1,1);
    
        glay->addWidget(yiBtn,6,0,1,1);
        glay->addWidget(erBtn,6,1,1,1);
        glay->addWidget(sanBtn,6,2,1,1);
        glay->addWidget(subBtn,6,3,1,1);
        glay->addWidget(zeroBtn,7,0,1,2);
    
        glay->addWidget(dotBtn,7,2,1,1);
        glay->addWidget(plusBtn,7,3,1,1);
        glay->addWidget(resBtn,6,4,2,1);
    
        //连接信号与槽函数
        connect(lBtn,SIGNAL(clicked()),this,SLOT(lBtnClick()));
        connect(rBtn,SIGNAL(clicked()),this,SLOT(rBtnClick()));
        connect(miBtn,SIGNAL(clicked()),this,SLOT(miBtnClick()));
        connect(jcBtn,SIGNAL(clicked()),this,SLOT(jcBtnClick()));
        connect(zhBtn,SIGNAL(clicked()),this,SLOT(zhBtnClick()));
    
        connect(qiBtn,SIGNAL(clicked()),this,SLOT(qiBtnClick()));
        connect(baBtn,SIGNAL(clicked()),this,SLOT(baBtnClick()));
        connect(jiuBtn,SIGNAL(clicked()),this,SLOT(jiuBtnClick()));
        connect(divBtn,SIGNAL(clicked()),this,SLOT(divBtnClick()));
        connect(clearBtn,SIGNAL(clicked()),this,SLOT(clearBtnClick()));
    
        connect(siBtn,SIGNAL(clicked()),this,SLOT(siBtnClick()));
        connect(wuBtn,SIGNAL(clicked()),this,SLOT(wuBtnClick()));
        connect(liuBtn,SIGNAL(clicked()),this,SLOT(liuBtnClick()));
        connect(mltBtn,SIGNAL(clicked()),this,SLOT(mltBtnClick()));
        connect(delBtn,SIGNAL(clicked()),this,SLOT(delBtnClick()));
    
        connect(yiBtn,SIGNAL(clicked()),this,SLOT(yiBtnClick()));
        connect(erBtn,SIGNAL(clicked()),this,SLOT(erBtnClick()));
        connect(sanBtn,SIGNAL(clicked()),this,SLOT(sanBtnClick()));
        connect(subBtn,SIGNAL(clicked()),this,SLOT(subBtnClick()));
        connect(zeroBtn,SIGNAL(clicked()),this,SLOT(zeroBtnClick()));
    
        connect(dotBtn,SIGNAL(clicked()),this,SLOT(dotBtnClick()));
        connect(plusBtn,SIGNAL(clicked()),this,SLOT(plusBtnClick()));
        connect(resBtn,SIGNAL(clicked()),this,SLOT(resBtnClick()));
    
        }
    }
    
    
    void Calculator::lBtnClick()
    {
        QString text = _resLbl->text();
        QString num = ")0123456879";
        if(!num.contains(text.at(text.size()-1)))//如果最后一个字符不是")0123456879"之中的才显示,(左括号前面一个不能是数字、右括号)
        {
            if(text=="0")//如果是初始"0",将0去掉
            {
                text = "";
            }
            _resLbl->setText(text+"(");
        }
    
    }
    void Calculator::rBtnClick()
    {
        QString text = _resLbl->text();
        QString op = "*/+-(.C!^";
        if(text!="0" && !op.contains(text.at(text.size()-1)))//如果不是初始"0"并且最后一个不是特殊字符才显示,(右括号前面一个不能特殊字符)
        {
            _resLbl->setText(_resLbl->text()+")");
        }
    }
    void Calculator::miBtnClick()
    {
        QString text = _resLbl->text();
        if(text!="0" && !text.contains(QRegExp("[*/+-().C!^]")))//如果不是初始"0"并且不包含指定运算符才显示,(保证只进行一次幂运算)
        {
            _resLbl->setText(_resLbl->text()+"^");
        }
    }
    void Calculator::jcBtnClick()
    {
        QString text = _resLbl->text();
        if(text!="0" && !text.contains(QRegExp("[*/+-().C!^]")))//如果不是初始"0"并且不包含指定运算符才显示,(保证只进行一次阶乘运算)
        {
            _resLbl->setText(_resLbl->text()+"!");
        }
    }
    void Calculator::zhBtnClick()
    {
        QString text = _resLbl->text();
        if(text!="0" && !text.contains(QRegExp("[*/+-().C!^]")))//如果不是初始"0"并且不包含指定运算符才显示,(保证只进行一次组合运算)
        {
            _resLbl->setText(_resLbl->text()+"C");
        }
    }
    void Calculator::qiBtnClick()
    {
        if(_resLbl->text().right(1)!=")")//数字不能跟在右括号后面
        {
            QString str1;
            str1 = _resLbl->text()=="0"?"":_resLbl->text();//如果是初始"0",将0去掉
            str1 += '7';
            _resLbl->setText(str1);
        }
    }
    void Calculator::baBtnClick()
    {
        if(_resLbl->text().right(1)!=")")//数字不能跟在右括号后面
        {
            QString str1;
            str1 = _resLbl->text()=="0"?"":_resLbl->text();
            str1 += '8';
            _resLbl->setText(str1);
        }
    }
    void Calculator::jiuBtnClick()
    {
        if(_resLbl->text().right(1)!=")")//数字不能跟在右括号后面
        {
            QString str1;
            str1 = _resLbl->text()=="0"?"":_resLbl->text();
            str1 += '9';
            _resLbl->setText(str1);
        }
    }
    void Calculator::divBtnClick()
    {
        QString text = _resLbl->text();
        QString op = "(.+-*/";
        if(text!="0" && !text.contains(QRegExp("[.C!^]")) && !op.contains(text.at(text.size()-1)))//如果不是初始"0",且不包含特殊运算符、并且最后一个不是四则运算符才显示,(两个四则运算符贴在一块表达式无效)
        {
            _resLbl->setText(_resLbl->text()+"/");
        }
    }
    void Calculator::clearBtnClick()
    {
        _resLbl->setText("0");//置为初始"0"
    }
    void Calculator::siBtnClick()
    {
        if(_resLbl->text().right(1)!=")")//数字不能跟在右括号后面
        {
            QString str1;
            str1 = _resLbl->text()=="0"?"":_resLbl->text();
            str1 += '4';
            _resLbl->setText(str1);
        }
    }
    void Calculator::wuBtnClick()
    {
        if(_resLbl->text().right(1)!=")")//数字不能跟在右括号后面
        {
            QString str1;
            str1 = _resLbl->text()=="0"?"":_resLbl->text();
            str1 += '5';
            _resLbl->setText(str1);
        }
    }
    void Calculator::liuBtnClick()
    {
        if(_resLbl->text().right(1)!=")")//数字不能跟在右括号后面
        {
            QString str1;
            str1 = _resLbl->text()=="0"?"":_resLbl->text();
            str1 += '6';
            _resLbl->setText(str1);
        }
    }
    void Calculator::mltBtnClick()
    {
        QString text = _resLbl->text();
        QString op = "(.+-*/";
        if(text!="0" && !text.contains(QRegExp("[.C!^]")) && !op.contains(text.at(text.size()-1)))//如果不是初始"0",且不包含特殊运算符、并且最后一个不是四则运算符才显示,(两个四则运算符贴在一块表达式无效)
        {
            _resLbl->setText(_resLbl->text()+"*");
        }
    }
    void Calculator::delBtnClick()
    {
        QString str1 = _resLbl->text();
        if(str1!="0")//不是初始状态才进行退格
        {
            str1 = str1.remove(str1.size()-1,1);
            if(str1=="")//如果已经全部删除掉表达式,重置为初始状态"0"
            {
                _resLbl->setText("0");
            }
            else
            {
                _resLbl->setText(str1);
            }
    
        }
    }
    void Calculator::yiBtnClick()
    {
        if(_resLbl->text().right(1)!=")")//数字不能跟在右括号后面
        {
            QString str1;
            str1 = _resLbl->text()=="0"?"":_resLbl->text();
            str1 += '1';
            _resLbl->setText(str1);
        }
    }
    void Calculator::erBtnClick()
    {
        if(_resLbl->text().right(1)!=")")//数字不能跟在右括号后面
        {
            QString str1;
            str1 = _resLbl->text()=="0"?"":_resLbl->text();
            str1 += '2';
            _resLbl->setText(str1);
        }
    }
    void Calculator::sanBtnClick()
    {
        if(_resLbl->text().right(1)!=")")//数字不能跟在右括号后面
        {
            QString str1;
            str1 = _resLbl->text()=="0"?"":_resLbl->text();
            str1 += '3';
            _resLbl->setText(str1);
        }
    }
    void Calculator::subBtnClick()
    {
        QString text = _resLbl->text();
        QString op = "(.+-*/";
        if(text!="0" && !text.contains(QRegExp("[.C!^]")) && !op.contains(text.at(text.size()-1)))//如果不是初始"0",且不包含特殊运算符、并且最后一个不是四则运算符才显示,(两个四则运算符贴在一块表达式无效)
        {
            _resLbl->setText(_resLbl->text()+"-");
        }
    }
    void Calculator::zeroBtnClick()
    {
        if(_resLbl->text().right(1)!=")")//数字不能跟在右括号后面
        {
            QString str1;
            str1 = _resLbl->text()=="0"?"":_resLbl->text();
            str1 += '0';
            _resLbl->setText(str1);
        }
    }
    void Calculator::dotBtnClick()
    {
        QString text = _resLbl->text();
        QString op = "().+-*/";
        if(text!="0" && !text.contains(QRegExp("[C!^]")) && !op.contains(text.at(text.size()-1)))//如果不是初始"0",且不包含特殊运算符、并且最后一个不是"().+-*/"之中的才显示,('.'之前只能是数字)
        {
            _resLbl->setText(_resLbl->text()+".");
        }
    }
    void Calculator::plusBtnClick()
    {
        QString text = _resLbl->text();
        QString op = "(.+-*/";
        if(text!="0" && !text.contains(QRegExp("[.C!^]")) && !op.contains(text.at(text.size()-1)))//如果不是初始"0",且不包含特殊运算符、并且最后一个不是"(.+-*/"之中的才显示,(两个四则运算符贴在一块表达式无效)
        {
            _resLbl->setText(_resLbl->text()+"+");
        }
    }
    void Calculator::resBtnClick()//进行计算结果
    {
        //拿到用户输入的表达式
        QString exp = _resLbl->text();
        //保存计算结果
        QString res = "";
        //进行组合运算时存储所有的组合
        QString all = "";
    
        if(exp.contains('^'))//表达式包含'^',进行幂运算
        {
            //保证只进行幂运算,去除其他运算符
            exp.replace(QRegExp("[*/+.C!]"),"");
            //获取底数
            QString str1 = exp.left(exp.indexOf('^')).remove('-');
            //获取指数
            QString str2 = exp.right(exp.size()-exp.indexOf('^')-1);
            //进行幂运算
            res = GetPow(str1,str2);
        }
        else if(exp.contains('!'))//表达式包含'!',进行阶乘运算
        {
            //保证只进行阶乘运算,去除其他运算符
            exp.replace(QRegExp("[*/+-.C^]"),"");
            //获取基数
            res = exp.left(exp.indexOf('!'));
            //以防表达式后面还有非法字符
            exp = res + "!";
            //进行阶乘运算
            res = GetJieCheng(res);
        }
        else if(exp.contains('C'))//表达式包含'C',进行组合运算
        {
            //保证只进行组合运算,去除其他运算符
            exp.replace(QRegExp("[*/+-.!^]"),"");
            //获取总数n
            QString str1 = exp.left(exp.indexOf('C'));
            //获取要取的个数m
            QString str2 = exp.right(exp.size()-exp.indexOf('C')-1);
            //进行组合运算
            all = "\n所有组合:\n"+GetCombine(str1,str2,res);
        }
        else//只包含四则运算
        {
            //保证只进行没有小数点的四则运算,去除'.'运算符
            exp.replace(".","");
            if(IsValid(exp))//如果计算表达式合法,才进行计算
            {
                //处理表达式、进行四则运算
                res = CountExp(exp);
            }
        }
    
        if(!res.isEmpty())//计算结果不为空、即输入表达式得到计算
        {
            //只显示结果
           _resLbl->setText(res);
        }
        //显示表示式与结果
        _allResBrws->setText(exp+"="+res+all);
    
    }
    bool Calculator::IsValid(QString exp)
    {
        bool valid = true;
        if(IsOp(exp.at(0)))//如果表达式第一个字符是运算符,不合法
        {
            valid = false;
        }
        if(exp.at(0)=='(')//如果表达式第一个字符是运算符'(',合法
        {
            valid = true;
        }
        if(exp.contains('(') || exp.contains(')'))//如果表达式包含括号,检查括号是否匹配
        {
            valid = IsMatch(exp);
        }
        return valid;
    }
    
    bool Calculator::IsMatch(QString exp)
    {
        int length = exp.size();//计算表达式的长度
        int match = true;//标志是否匹配
    
        //栈初始化
        QList<QChar> stack;
        int top = -1;//指示栈顶
    
        for(int i = 0;i<length;i++)
        {
            if(exp[i]=='(')//如果是'('进栈 (只有'('才能进栈)
            {
                ++top;
                stack.push_back(exp[i]);
            }
            else if(exp[i]==')')//如果是')'出栈
            {
                if(top == -1)//如果栈空、没有与该右括号匹配,跳出循环
                {
                    match = false;
                    break;
                }
                else       //如果栈不为空、与该右括号匹配、出栈(栈中只有'(')
                {
                    --top;
                }
    
            }
    
        }
    
        if(match && top== -1)//匹配所有')',并且栈没有多于的'('
        {
            return true;
        }
        else
        {
           return false;
        }
    }
    

    exp.cpp文件

    #include "exp.h"
    
    QVector<QChar> op;//模拟栈、用来存储表达式中的运算符
    int op_top = -1;//运算符索引指示
    
    QVector<QString> num;//模拟栈、用来存储表达式中的运算数
    int num_top = -1;//运算数索引指示
    
    struct	PRI		//用来存储运算符的优先级
    {
        QChar op;	//运算符
        int pri;	//优先级
    };
    
    //定义左运算符优先级结构体数组
    struct PRI lpri[] = {{'=',0},{'(',1},{'+',3},{'-',3},{'*',5},{'/',5},{')',6}};
    
    //定义右运算符优先级结构体数组
    struct PRI rpri[] = {{'=',0},{'(',6},{'+',2},{'-',2},{'*',4},{'/',4},{')',1}};
    
    int LeftPri(QChar op)//求左运算符op的优先级
    {
        int i = 0;//计数器
        for(i = 0;i < sizeof(lpri)/sizeof(lpri[0]);i++)//求左运算符的个数sizeof(lpri)/siozeof(lpri[0])
        {
            if(lpri[i].op == op)//如果 左运算符结构体有匹配的运算符
            {
                return lpri[i].pri;//返回对应的运算符的优先级
            }
        }
    
        return -1;//没有匹配的运算符
    }
    
    
    int RightPri(QChar op)//求右运算符op的优先级
    {
        int i = 0;//计数器
        for(i = 0;i < sizeof(rpri)/sizeof(rpri[0]);i++)//求右运算符的个数sizeof(lpri)/siozeof(lpri[0])
        {
            if(rpri[i].op == op)//如果 右运算符结构体有匹配的运算符
            {
                return rpri[i].pri;//返回对应的运算符的优先级
            }
        }
    
        return -1;//没有匹配的运算符
    }
    
    
    int IsOp(QChar ch)//判断ch是否是运算符
    {
        //如果是指定的运算符则返回1,否则返回0
        if(ch == '*' || ch == '/' || ch == '+' || ch == '-' || ch == '(' || ch == ')' )
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
    
    
    int JudgePri(QChar lop,QChar rop)//判断左右运算符的优先级  左运算符大于右运算符返回1,相等返回0,左小于右返回-1
    {
        if(LeftPri(lop)> RightPri(rop))//左运算符大于右运算符返回1
        {
            return 1;
        }
        else if(LeftPri(lop)== RightPri(rop))//相等返回0,只有左右括号这一种情况
        {
            return 0;
        }
        else                        //左运算符小于右运算符返回-1
        {
            return -1;
        }
    }
    
    
    QString CountExp(QString exp) //处理运算表达式
    {
        //初始化,清空操作符栈、运算数栈、重置站顶指示指针
        op.clear();
        num.clear();
        op_top = num_top = -1;
    
        //将'='进栈,等号是为了辅助比较其他运算符
        op_top++;
        op.push_back('=');
    
        //临时存储一个运算数、因为表达式是字符串、需要通过运算符的位置识别出每一个运算数、
        //strnum就是临时存储识别出的运算数
        QString strnum = "";
        //表达式的指示索引,用来指示访问表达式的每一个字符
        int exp_index = 0;
    
        //循环扫描exp表达式,识别出每一个运算数、运算符并行操作
        while(exp_index<exp.size())
        {
            if(!IsOp(exp.at(exp_index)))//如果不是运算符,即是运算数
            {
                strnum = "";//每次识别之前需要将临时变量重置,将上次数据清除
    
                //遇到字符是数字,继续扫描将后面连续的数字字符组合称为一个数字字符串、存放在临时变量strnum中
                while(exp_index<exp.size() && exp.at(exp_index)>='0' && exp.at(exp_index)<='9')
                {
                    strnum.insert(strnum.size(),exp.at(exp_index++));//将数字字符添加到str中,添加后i加1
                }
    
                //运算数进栈
                ++num_top;
                //用QVector模拟栈,出栈了并不pop,只是指示指针发生变化,
                //所以当指示索引小于QVector大小时,有空闲空间,无需申请空间
                if(num_top < num.size())
                {
                    num[num_top]= strnum;
                }
                else//无空闲空间,需申请空间
                {
                    num.push_back(strnum);
                }
            }
            else  //是运算符
            {
                //先进行优先级判断,然后根据优先级进行相应的操作
                switch(JudgePri(op[op_top],exp.at(exp_index)))
                {
                    case -1://栈顶的运算符优先级低,进栈
                            op_top++;
                            if(op_top < op.size())
                            {
                                op[op_top]=exp.at(exp_index);
                            }
                            else
                            {
                                op.push_back(exp.at(exp_index));
                            }
                            break;
                    case 0://优先级一样,说明是括号 ,只有这一种情况
                            op_top--;//将'('退栈
                            break;
                    case 1://栈顶的运算符优先级高,先出栈进行计算,后入栈
                            Count(op[op_top--]);//*/+- 运算
                            if(exp.at(exp_index) != ')')//如果不是')'才入栈
                            {
                                ++op_top;
                                if(op_top < op.size())
                                {
                                    op[op_top]=exp.at(exp_index);
                                }
                                else
                                {
                                    op.push_back(exp.at(exp_index));
                                }
                            }
                            break;
                    default:
                            break;
                }
                ++exp_index;//继续向下扫描exp
            }
    
        }
    
    
        for(int i = op_top;i>0;i--)//因为上面是按根据表达式执行的,扫描执行先进栈而还没有出栈的运算符
        {
            Count(op[i]);
        }
        return num[0];//num.data[0];
    }
    
    
    
    void Count(QChar op)//*/+-四则运算
    {
        QString temp = "0"; //用来存放临时计算结果;
        if(op == '*')
        {
            temp = num[num_top--];//取出两个数相乘
            temp = GetMlt(temp,num[num_top--]);
            num[++num_top] = temp;//将计算结果进栈
        }
        else if(op == '/')
        {
            temp = num[num_top--];//取出被除数 注意是倒着取的
            if(temp=="0") //被除数不能为0
            {
                qDebug()<<"\n被除数为0";
                return;
            }
            temp =  GetDiv(num[num_top--],temp); //取出除数         1 ÷2 1是除数,2是被除数
            num[++num_top] = temp;//将计算结果进栈
        }
        else if(op == '+')
        {
            temp = num[num_top--];//取出两个数相加 ,顺序不影响相加
            temp = GetSum(temp,num[num_top--]);
            num[++num_top] = temp;//将计算结果进栈
    
        }
        else if(op == '-')
        {
    
            temp = num.at(num_top--);//取出被减数 ,注意是倒着取的
            temp = GetSub(num.at(num_top--),temp);
            num[++num_top] = temp;//将计算结果进栈
        }
    
    }

    getCombine.cpp文件

    #include <QString>
    #include <QVector>
    #include "getsub.h"
    #include "getsum.h"
    
    int CmpStr(QString str1,QString str2);
    QString GetCombine(QString str1,QString str2,QString& res)
    {
        QVector<int> arr;  //用来存储索引集合
        int n = 0,m = 0,count = 0;//count组合种数
        n = str1.toInt();//总数
        m = str2.toInt();//取的个数
        QString all = "";//保存所有组合
        if(m>n || m<1) return "确保n>=m>=1"; //确保n>=m>=1
    
        for(int i=1;i<=n;i++)//填充索引
        {
            arr.push_back(i);
        }
    
        QVector<int> a;//用来存储每次算法产生的当前组合
        for(int i=0;i<m;i++)//第一种组合,a[0]=1,a[1]=2,...a[m-1]=m;
        {
            a.push_back(i+1);
        }
    
        for(int j=m;a[0]<=(n-m+1);)//当组合为最后一组时,循环结束;即a[0]=n-m+1,...,a[m-1]=n;j用来判断进位,以及进位之后的调整
        {
    
            for(;a[m-1]<=n;a[m-1]++)//最后一位不断递增,直到达到最大值,产生进位
            {
                for(int t=0;t<m;t++)
                {
                    all.insert(all.size(),QString::number(arr[a[t]-1])+"    ");
    
                }
                count++;
                all.insert(all.size(),"\n");//换行,方便查看所有的组合
    
            }
    
            for(j=m-2;j>=0;j--)//判断a[1]--a[m-2]是否有进位 如果 a[m-1]>n 产生进位
            {
                a[j]++;
                if(a[j]<=(j+n-m+1))//a[j]不进位,那么a[j-1]也不进位,结束继续判断
                {
                    break;
                }
            }
    
            for(j++;j>0 && j<m;j++)//调整,使得a[index-1],a[index],a[index]顺序排列,其中a[index]产生进位
            {
                a[j] = a[j-1]+1;
            }
        }
        //组合种数
        res.setNum(count);
        //全部组合
        return all;
    }

    getDiv.cpp文件

    #include <QString>
    #include <getdiv.h>
    #include <getsub.h>
    #include <stdlib.h>
    #include <QDebug>
    
    QString GetDiv(QString str1,QString str2)//模拟笔算除法
    {
        int i = 0,j = 0;
        //结果:res
        QString res = "",temp = "",s1 = "";
        //计算除数长度
        int len1 = str1.length();
        //计算被除数的长度
        int len2 = str2.length();
        //指示"当前除数"的位数    "当前除数"不够除时 若是除数还有数字,则"当前除数"后面加相应的数字,否则加0
        int index = len2;
    
        if(len1>len2)//除数长度大于被除数,那么除数>被除数
        {
            //比如123/3  先拿到相等位数1(暂时称作“当前除数”) 若是小于被除数3则再拿一位 变成12
            s1 = str1.left(len2);
            if(CmpStr(s1,str2)<0)//若是小于被除数
            {
                s1.insert(len2,str1.at(index++));//再拿一位
            }
    
            for(i=0;i<len1+50;i++)//控制计算结果的位数
            {
                while(s1.size()>0 && CmpStr(s1,str2)<0)//“当前除数”小于被除数,进行补位,直到“当前除数”大于除数
                {
                    res.insert(res.length(),"0");//商补0
                    //若是除数还有数字,则"当前除数"后面加相应的数字,否则加0
                    index>= len1?s1.insert(s1.size(),"0"):s1.insert(s1.size(),str1.at(index++));
                }
    
                j = 0;//j保存每次试出的商
                do
                {
                    if(s1.size()>0)
                    {
                        s1 = GetSub(s1,str2);//用减法试商
                        j++;//每减一次加1
                    }
                    else//已经减到小于0,最后一次去掉,j就是本次的商
                    {
                        j = -1;
                    }
                }while(s1.size()>0 && CmpStr(s1,str2) >= 0);//只要"当前除数">0 并且大于被除数 继续减法试商
    
    
                if(index>len1 || index==len1)
                {
                    s1.insert(s1.size(),"0");
                    while(s1.size()>0 && s1.at(0)== '0')
                    {
                        s1.remove(0,1);
                    }
                    index++;
                    if(index==len1+2 && j!=-1)
                    {
                        res.insert(res.length(),".");
                    }
                }
                else
                {
                    s1.insert(s1.size(),str1.at(index++));
                    while(s1.size()>0 && s1.at(0)== '0')
                    {
                        s1.remove(0,1);
                    }
                }
                if(j!=-1)res.insert(res.length(),temp.setNum(j));
            }
    
        }
        else //除数长度小于等于被除数,那么除数<=被除数
        {
            //保证"当前除数"大于被除数
            if(str1.size()>0 && CmpStr(str1,str2)<0)//除数<被除数
            {
                res = "0.";//结果补0,并且添加小数点
                str1.insert(len1,"0");//"当前除数"补0
            }
    
            //减法试商
            for(i=0;i<len2+60;i++)//试商次数,结果的位数控制
            {
                //保证"当前除数"大于被除数
                while(str1.size()>0 && CmpStr(str1,str2)<0)//除数<被除数
                {
                    res.insert(res.length(),"0");//结果补0
                    str1.insert(str1.length(),"0");//"当前除数"补0
                }
    
                //去掉"当前除数"前面的0
                while(str1.size()>0 && str1.at(0)== '0')
                {
                    str1.remove(0,1);
                }
    
                j = 0;//每次的试商
                //循环试商
                do
                {
                    if(str1.size()>0)//"当前除数"位数大于0,才进行试商(整除的时候str1为空)
                    {
                        str1 = GetSub(str1,str2);//减法试商
                        j++;//每减1次,加1
                    }
                    else//整除的时候str1为空
                    {
                        j=-1;
                    }
                }while(str1.size()>0 && CmpStr(str1,str2) >= 0);//"当前除数">=被除数,继续减法试商
    
    
                str1.insert(str1.length(),"0");//试完商,"当前除数"后面补0
    
                while(str1.size()>0 && str1.at(0)=='0')//将"当前除数"前面的0去掉
                {
                    str1.remove(0,1);
                }
    
                if(j!=-1)//试商不为-1,即合法
                {
                    res.insert(res.length(),temp.setNum(j));//将试商追加添加到结果
                }
    
                if(!str1.isEmpty() && str1 != "0" && res.size() == len2)
                {
                    res += ".";//不能整除时,添加小数点
                }
    
                if(str1.size()==0)
                {
                    break;//试商结束,结束循环
                }
    
            }
        }
        //qDebug()<<res;
        return res;
    }
    
    int CmpStr(QString str1,QString str2)
    {
        //计算两个比较数的长度
        int len1 = str1.length();
        int len2 = str2.length();
    
        if(len1>len2)//str1位数大
        {
            for(int i=0;i<len1-len2;i++)//补0,直到一样的位数
            {
                str2.insert(0,"0");
            }
        }
        else//str2位数>=str1
        {
            for(int i=0;i<len2-len1;i++)//补0,直到一样的位数
            {
                str1.insert(0,"0");
            }
        }
    
        //位数相同后,调用自带的函数进行比较
        return str1.compare(str2);
    }

    getJieCheng.cpp文件

    #include "getjiecheng.h"
    
    QString GetJieCheng(QString str)
    {
        //0的0次方为1,1的n次方为1(n>=0)
        if(str == "0" || str == "1")
        {
            return "1";
        }
        //保存计算结果
        QString res = "1";
    
        while(str!="1")
        {
            //累乘一次
            res = GetMlt(res,str);
            //str减1
            str = GetSub(str,"1");
        }
        return res;
    }

    getMlt.cpp文件

    #include <getmlt.h>
    
    QString GetMlt(QString str1,QString str2)
    {
        //获取乘数1的长度
        int len1 = str1.size();
        //获取乘数2的长度
        int len2 = str2.size();
    
        //申请足够的空间保存结果
        int *pres= (int *)malloc(sizeof(int)*(len1+len2));
        //将申请到的空间清零
        memset(pres,0,sizeof(int)*(len1+len2));
    
        //对应位相乘,并将结果存放到pres
        for(int i=0;i<len1;i++)
        {
            for(int j=0;j<len2;j++)
            {
                 pres[i+j] += (str1.at(len1-1-i).digitValue())*(str2.at(len2-1-j).digitValue());
    
            }
        }
    
        //进位处理
        for(int i=0;i<len1+len2;i++)
        {
            if(pres[i]>=10)//>=10即有进位
            {
                pres[i+1] += pres[i]/10;//算出进多少个,加到高一位
                pres[i] %= 10;//取余作为本位
            }
    
        }
    
        //i指示最高非0位
        int i = len1+len2-1;
        while(pres[i]==0)
        {
            i--;
        }
    
    
        //将计算结果存放到字符串strres
        QString strres="";
        for(int j=i;j>=0;j--)
        {
            strres += QString::number(pres[j]);
        }
    
        //释放空间
        free(pres);
        return strres;
    }
    

    getPow.cpp文件

    #include <getpow.h>
    
    QString GetPow(QString str1,QString str2)
    {
        //指数是否是负数的标志
        bool flag = false;
        //如果指数是负数
        if(str2.at(0)== '-')
        {
            flag = true;//标志指数为负数
            str2.remove(0,1);//将负号去掉,先按照正数计算
        }
        //不小于0的数的0次方,结果为1
        if(str2 == "0") return "1";
        //指数为1,基数不为0,结果为本身
        if(str2 == "1")return str1;
    
        //以下是指数>=2
        //指数减1,结果累积一个基数
        str2 = GetSub(str2,"1");
        //存放计算结果
        QString res = str1;
    
        while(str2 != "0")
        {
            //指数减1
            str2 = GetSub(str2,"1");
            //结果累积一个基数
            res = GetMlt(res,str1);
        }
        if(flag)//如果指数是负数,前面加上"1/"
        {
            res = "1/"+res;
        }
        return res;
    }

    getSub.cpp文件

    #include <getsub.h>
    
    QString GetSub(QString str1,QString str2)
    {
        if(str1.isEmpty() || str2.isEmpty())
        {
            return "0";
        }
        //计算结果,字符串形式
        QString strres="";
    
        bool fushu1 = false;//指示减数是否是负数
        bool fushu2 = false;//指示被减数是否是负数
    
        if(str1.at(0)=='-')//减数是负数
        {
            fushu1 = true;
            str1.remove(0,1);//去掉负号
        }
    
        if(str2.at(0)=='-')//被减数是负数
        {
            fushu2 = true;
            str2.remove(0,1);//去掉负号
        }
    
        //负-负,交换str1,str2
        if(fushu1 && fushu2)
        {
            str1.swap(str2);
        }
        else if(fushu1 && !fushu2)//正-负
        {
            strres = GetSum(str1,str2);
            return strres;
        }
        else if(fushu1 && !fushu2)//负-正
        {
            strres = "-"+GetSum(str1,str2);
            return strres;
        }
    
        //正-正
        //减数的长度
        int len1 = str1.size();
        //被减数的长度
        int len2 = str2.size();
    
        //记录位数最长的
        int len = len1>len2?len1:len2;
        //申请足够空间
        int *pres= (int *)malloc(sizeof(int)*(len));
        //将申请到的空间清零
        memset(pres,0,sizeof(int)*(len));
    
        if(len1==len2)//减数与被减数的位数相同
        {
            if(str1.compare(str2)==0)//减数=被减数
            {
                return "0";
    
            }
            else if(str1.compare(str2)>0)//减数>被减数
            {
    
                for(int i=0;i<len1;i++)//对应位相减
                {
                     pres[i] = (str1.at(len1-1-i).digitValue())-(str2.at(len2-1-i).digitValue());
                }
    
            }
            else//str2>str1,被减数大于减数
            {
                //按照最小位数的、对应位相减,并存到pres
                for(int i=0;i<len1;i++)
                {
                     pres[i] = (str2.at(len2-1-i).digitValue())-(str1.at(len1-1-i).digitValue());
                }
    
                strres += "-";
            }
        }
        else if(len1>len2)//str1位数>str2位数
        {
            for(int i=0;i<len1-len2;i++)
            {
                str2.insert(0,"0");
            }
    
            for(int i=0;i<len1;i++)
            {
                pres[i] = str1.at(len1-1-i).digitValue()-str2.at(len1-1-i).digitValue();
            }
    
    
        }else//str2位数>str1位数
        {
            for(int i=0;i<len2-len1;i++)
            {
                str1.insert(0,"0");
            }
            for(int i=0;i<len2;i++)
            {
                 pres[i] = (str2.at(len2-1-i).digitValue())-(str1.at(len2-1-i).digitValue());
            }
        }
    
        //实现借位 (处理<0的数)
        pres[len-1] -= 1;//最高位减1(注意结果倒放)
        for(int i=1;i<len-1;i++)
        {
            pres[i] += 9;//中间加9
        }
        pres[0] += 10;//最低位加10
    
        //借位后、进位处理  (处理>=10的数)
        for(int i=0;i<len;i++)
        {
            if(pres[i]>=10)//进位处理
            {
                pres[i+1] +=pres[i]/10;//取得多少个10,进到高一位
                pres[i]%=10;//取余数作为本位
            }
    
        }
    
        if(len==1)
        {
            pres[0] +=1;//一位数时需要加1修正
        }
    
        //i指示计算结果的最高非0位置
        int i = len-1;
        while(pres[i]==0)
        {
            i--;
        }
    
        //将结果转换成字符串
        for(int j=i;j>=0;j--)
        {
            strres += QString::number(pres[j]);
        }
    
        if(len1<len2)//减数小于被减数
        {
            strres.insert(0,'-');
        }
        //释放空间
        free(pres);
        return strres;
    }

    getSum.cpp文件

    #include <getsum.h>
    
    QString GetSum(QString str1,QString str2)
    {
        //获取加数1的长度
        int len1 = str1.size();
        //获取加数2的长度
        int len2 = str2.size();
    
        //申请足够的空间保存计算结果
        int len = len1>len2?len1+1:len2+1;
        int *pres= (int *)malloc(sizeof(int)*len);
        //将申请到的空间清零
        memset(pres,0,sizeof(int)*(len));
    
        if(len1==len2)//加数1的位数与加数2的位数一样
        {
            //对应位相加
            for(int i=0;i<len1;i++)
            {
                 pres[i] = (str1.at(len1-1-i).digitValue())+(str2.at(len2-1-i).digitValue());
            }
    
        }else if(len1 > len2)//加数1的位数>加数2的位数
        {
            //按最小位数的进行对应位相减
            for(int i=0;i<len2;i++)
            {
                 pres[i] = (str1.at(len1-1-i).digitValue())+(str2.at(len2-1-i).digitValue());
            }
            //多出的直接加到结果
            for(int i= len2;i<len1;i++)
            {
                pres[i] = str1.at(len1-1-i).digitValue();
            }
    
        }else//加数1的位数<加数2的位数
        {
            //按最小位数的进行对应位相减
            for(int i=0;i<len1;i++)
            {
                pres[i] = (str1.at(len1-1-i).digitValue())+(str2.at(len2-1-i).digitValue());
            }
            //多出的直接加到结果
            for(int i= len1;i<len2;i++)
            {
                pres[i] = str2.at(len2-1-i).digitValue();
            }
        }
    
        //进位处理
        for(int i=0;i<len;i++)
        {
            if(pres[i]>=10)
            {
                pres[i+1] +=pres[i]/10;
                pres[i]%=10;
            }
    
        }
    
        //i指示最高非0位位置
        int i = len-1;
        while(pres[i]==0)
        {
            i--;
        }
    
        //将结果添加到结果字符串strres
        QString strres="";
        for(int j=i;j>=0;j--)
        {
            strres += QString::number(pres[j]);
        }
    
        //释放空间
        free(pres);
        return strres;
    }

    main.cpp文件

    #include <QApplication>
    #include <calculator.h>
    
    int main(int argc,char* argv[])
    {
        QApplication app(argc,argv);
        Calculator w;
        w.setWindowTitle("计算器");
        w.setWindowFlags(Qt::WindowCloseButtonHint);//只留下关闭按钮
        w.show();
        return app.exec();
    }

    五、总结

        合法性检测有待加强、实现的字符串运算的算法较为脆弱、没有实现小数运算

    展开全文
  • 想要判断一个字符串是浮点数还是小数,可以应用int()或者float即可了。 def isfloat(str_number): try: int(str_number)//如果是浮点数,那么就是报错,原因是这里str_number为字符串 return False except ...
  • 1.式子中开头的^结尾的$限定字符串的开始结尾; 2."-?" 表示一个或0个负号,这里面的问号表示其前面的字符重复0次或1次; 3.[0-9] 表示限定数字范围0到9, 6."[0-9] +",这里面的+表示其前面的\d重复一次或多...
  • 在做项目的过程中我们经常会遇到输入数字、字母这类的问题,有时候需要判断用户输入的信息是否按要求输入,这里就用到了正则表达式,Qt中QRegExp是正则表达式类。QRegExpValidator类是用来检查一个字符串正则表达式...
  • 字符串数字,包括正数,负数,小数/**字符串转换整数 * @param str * @return */ public static int strToInt(String str){ int result=0; if(isNum(str)){ result=Integer.valueOf(str);
  • Qt实现计算器(支持负数和小数)

    千次阅读 2019-10-07 19:12:37
    计算器主要利用了栈这种数据结构,需要用的知识有逆波兰...但是对于计算机计算这种表达式就有点困难了,因为中间涉及括号运算符号的优先级问题,因为如果计算机从左向右扫一遍的话不知道先计算哪些值,哪个...
  • 1.期望实现:数字 ===&gt; 中文大写如: 123.0456 ===&gt; 壹贰叁点零肆伍陆 12003045.678 ===&gt; 壹仟贰佰零万叁仟...
  • Qt string 保留小数点后固定位数

    千次阅读 2019-08-16 10:14:03
    1. 保留小数点后固定位数 double num = 1.23334423423; QString str = QString::number(num, 'f', 2);...2. Qt 去掉小数点后多余的 0 QRegExp rx; rx.setPattern("(\\.){0,1}0+$"); double double01 = 15...
  • QT 小数点位数

    2013-06-03 17:34:15
     QString number ( double n, char format = 'g', int precision = 6 ) 来设置小数点位数 double a=27.846234; QString result=QString::number(a,'f',2); // "27.85"...result=QString::number(a,'g',2...
  • Qt5 之QString类的使用

    2021-03-30 22:04:17
    QString 是Qt编程中常用的类,除了用作数字量的输入输出之外,QString 还有很多其他功能,熟悉这些常见的功能,有助于灵活地实现字符串处理功能。 QString 存储字符串釆用的是 Unicode 码,每一个字符是一个 16 位...
  • 如何在QT中使用正则表达式

    千次阅读 2021-01-04 00:08:16
    正则表达式有许多方便应用,比如:检验游戏玩家名字是否符合格式、取得一串字符串中所有子数列 这种子数列是一个小写字母加一个大写字母、对输入框LineEdit中的输入内容加以限制 比如只能输入数字 并且最多5
  • 字符串练习题 Python 切片 函数修饰符 #精度进制 Python 字符串一些语句练 课件练习题 4,。by 字符串的替换 方法 描述 replace 从左到右替换指定的元素,可以指定替换的个数,默认全部替换 translate 按照...
  • qt的三种验证类:   1。输入int类型   QValidator *validator=new QIntValidator(100,999,this); QLineEdit *edit=new QLineEdit(this); edit->setValidator(validator);   也可以表示成  ...
  • 数组操作方法 join 将数组按特定标志组合成字符串,默认分隔逗号 split 将字符串按照特定的分隔符转换成数组,可以自定义分隔符位置 reverse 用于颠倒数组中元素的顺序(由大到小或者由小到大相互切换) concat 用于...
  • Qt中,界面经常会用来显示一些结果,当显示的数据值过大时,QT会直接转换成科学计数法显示。 但是在有些项目中,对数据有特定的显示要求,有时候需要用科学计数法显示,有时候一定要用非科学计数法显示。 那么该...
  • 概述:上篇我主要介绍了用QT做计算器的整个流程,这次主要就是分析一下,计算器表达式计算的算法部分。因为也找了很多别人写的代码,但大多都是只支持个位数的加减乘除,小数也不支持,所以就在原有框架上,修改,...
  • 1.限制浮点数输入范围[-180,180] QRegexp rx("^-?(180|([1-9]?[0-9]|1[0-7][0-9])(\\.\\d)?)$"); QRegExpValidator *pReg = new QRegExpValidator(rx, this); lineEdit->setValidator(pReg);2.
  • QT——实现简易计算器

    千次阅读 2020-07-26 12:47:53
    1.用户界面类设计 需要使用QWidget组件作为顶层窗口,QLineEdit组件作为输入框,QPsuhButton作为按钮 1.1 在代码里处理按键...2)判断每个按键是否合法 数字前面不能:右括号 比如: 10+3)5*2 //出错,数字5前面不能
  • /* * FormulaCalculator.java * * Created on 2007年9月18日, 上午11:40 * @title 转化字符串表达式数学公式并算出结果 ... * @description 转化字符串表达式数学公式并算出
  • QT QSting的用法

    2019-11-28 00:02:12
    八、判断字符串是否存在,是否为空 九、测试代码: 一、创建 QString str1 = "Hello1"; QString str2 = QString("%1 to %2").arg("Welcome").arg("QT!"); 二、插入 //1、插入字符 在X位置插...
  • QVariant类是常见的Qt数据类型的一个共用体(union),一个QVariant对象可以存储一个单一类型的单一的值(有些类型可能多值,如字符串列表)。可以使用toT()函数进行将QVariant 转换一个T类型数据,并获取它的值...
  • Qt中的基本数据类型

    千次阅读 2018-11-26 18:33:17
    2.9查找是否包含另一个字符串 bool x; QString str ="Stick question"; QString str1="sti"; x=str.contains(str1);//true 2.10字符串截取 QString str ="Stick question"; QString str1="sti"; - ...
  • 文章目录运算符与表达式常用运算符分类算术运算符两个数相除,要想得到小数,分子分母必须有一个是小数,否则结果只会取整(可以把其中一个数乘以1.0)赋值运算符比较运算符逻辑运算符运算符优先级类型转换隐式转换...
  • 首先,在没有做出交互界面的情况下我们假定用户以英文键盘输入所要计算的表达式,这时你就会得到一个字符串,为了将字符串中每一个数字或运算符进行分割抽离,我们可以选用一个vector容器储存单独
  • 20200518 ...QT += core gui widgets(用空格的形式添加了guiwidgets这2个模块) #QT += core gui widgets //用#注释,编译时会出现“没有那个文件或目录”的错误 2. 生成Makefile文件 命令行输入q...
  • 环境:QtCreator,功能:正则匹配正数、负数、浮点数 QString text="-10"; QString pattern("^(-?[0-9])|(-?\\d+)(\.\\d+)$"); //Qt匹配正数、负数、浮点数 ... //trimmed() 去除字符串前后的...
  • qt学习总结

    2021-04-22 12:47:05
    //将字符串列表绑定 QComboBox 控件 //整形分量框 #include QSpinBox *spinBox; //声明控件 spinBox = new QSpinBox(this); //创建 spinBox->setGeometry(QRect(50,50,100,25)); //位置 spinBox->setRange(0...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 510
精华内容 204
关键字:

qt判断字符串是否为数字和小数