精华内容
下载资源
问答
  • 本来是想写一个函数,在下发参数时,传QLineEdit字符串参数进去,然后判断是否合法,如果不合法,则不下发参数,请用户修改后再确认。这么做也实现了,但是想Qt这么强大,应该会考虑到这一点,所...

    b173d277c3e4072889dda07336b6cde5.png

    前言

    最近做了一个小的上位机,要通过串口来下发几个时间参数,为了防止误输入,产生不必要的麻烦,我把输入范围限制在0-680的浮点型数据,支持小数点后2位。学习了一下QLineEdit类是如何限制输入类型的。本来是想写一个函数,在下发参数时,传QLineEdit的字符串参数进去,然后判断是否合法,如果不合法,则不下发参数,请用户修改后再确认。这么做也实现了,但是想Qt这么强大,应该会考虑到这一点的,所以找了个更简单,在输入的时候就限制数据的类型,不合法的根本输入不进去。

    关于QLineEdit类

    QlineEdit是一个单行文本输入框,支持撤销、重做、复制、粘贴、拖放等操作,echomode模式支持,即只写模式,可以输入密码等不可见的文本,官方介绍:QLineEdit Class

    可以通过setValidator函数来限制数据类型,

    setValidator函数的参数是QValidator,主要有3种:

    • QIntValidator //限制只能输入整数,限制范围
    • QDoubleValidator //限制只能输入浮点数,包括范围,小数点位数
    • QRegExpValidator //限制规则按指定的正则表达式

    Amazing!QDoubleValidator不就是我想要的吗?但是经过实际测试发现,其中QDoubleValidator可以限制浮点型数据和输入的小数位数,但是并不能限制输入范围,也就是setRange,setBottom,setTop这些函数的设置并没有生效,这难道是Qt的一个Bug?我的Qt版本是5.8.0,Qt Creator版本是4.2.1,而QRegExpValidator的使用就很强大了,需要了解正则表达式的相关知识。下面来详细介绍一下这三种类的使用。

    QIntValidator Class

    • 功能

    限制QLineEdit只能输入int类型数据,即整型数据,包含正负整数和0

    • 相关函数

    c++ //限制数据范围 QIntValidator(int minimum, int maximum, QObject *parent = Q_NULLPTR) //获取最小值 int bottom() //设置最小值 void setBottom(int) //设置数据范围 void setRange(int bottom, int top) //设置最大值 void setTop(int) //获取最大值 int top() const

    • 示例
      ```c++ //整型限制范围100-999 lineEdit->setValidator(new QIntValidator(100, 999, this));
      //或者 QIntValidator* aIntValidator = new QIntValidator; aIntValidator->setRange(100, 999); ui->le_L1->setValidator(aIntValidator); ```

    QDoubleValidator Class

    • 功能

    限制QLineEdit只能输入浮点型数据,可以指定输入范围及小数点位数

    • 相关函数
      ```c++ //限制数据范围 QDoubleValidator(double bottom, double top, int decimals, QObject *parent = Q_NULLPTR) //设置小数点位数 void setDecimals(int) //获取设置的小数点位数 int decimals() //设置数字表示方式,标准计数法还是科学计数法 void setNotation(Notation) //获取设置的计数方式 Notation notation() //设置最小值 void setBottom(double) //获取设置的最小值 double bottom() //设置最大值 void setTop(double) //获取设置的最大值 double top() //设置数据范围,默认无小数位 void setRange(double minimum, double maximum, int decimals = 0)
      ```
    • 示例
    //限制范围0-680,小数点2位
    lineEdit->setValidator(**new** QDoubleValidator(0,680,2,**this**));
    

    限制范围无效,这可能是Qt的一个Bug。

    QRegExpValidator Class

    • 功能

    按照自定义的正则表达式规则,限制输入的范围。

    • 相关函数
    //设置按正则表达式限制
    QRegExpValidator(const QRegExp &rx, QObject *parent = Q_NULLPTR)
    //获取设置的正则表达式
    QRegExp &regExp() 
    //设置正则表达式
    void setRegExp(const QRegExp &rx)
    
    • 示例
    //限制-180,180,并限定小数点后4位
    QRegExp rx("^-?(180|1?[0-7]?d(.d{1,4})?)$");  
    QRegExpValidator *pReg = new QRegExpValidator(rx, this);  
    lineEdit->setValidator(pReg);
    

    关于正则表达式

    正则表达式,又称规则表达式(英语:Regular Expression,在代码中常简写为regex、regexp或RE),计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。许多程序设计语言都支持利用正则表达式进行字符串操作。例如,在Perl中就内建了一个功能强大的正则表达式引擎。正则表达式这个概念最初是由Unix中的工具软件(例如sed和grep)普及开的。正则表达式通常缩写成“regex”,单数有regexp、regex,复数有regexps、regexes、regexen。

    关于正则表达式的详细介绍:正则表达式30分钟入门教程

    //正则表达式说明:
    /*
    
    ^(-?[0]|-?[1-9][0-9]{0,5})(?:.d{1,4})?$|(^t?$)
    (^-?180$)|(^-?1[0-7]d$)|(^-?[1-9]d$)|(^-?[1-9]$)|^0$
    ^-?(180|1?[0-7]?d(.d+)?)$
    ^-?(180|1?[0-7]?d(.d{1,4})?)$
    ^-?(90|[1-8]?d(.d{1,4})?)$
    
     式子中开头的^和结尾的$限定字符串的开始和结尾;
     "-?" 表示一个或0个负号,这里面的问号表示其前面的字符重复0次或1次;
     管道符“|”表示平行分组,比如后三个,表示180或其它形式;
     [1-9] 表示限定数字范围为1到9,其余类似,如果是有限几个值,还可以用枚举的方式,比如限定-255到255时,第一个数字2的限定,应该表达为[1,2],这表示这个位置只允许是1或者2;
     "d"是一个转义字符,表示匹配一位数字;
     “.” 表示匹配小数点;
     "d+",这里面的+表示其前面的d重复一次或多次;
     "d{1,4}",里面的{1,4}表示重复1到4次;
    
    */
    

    关于QDoubleValidator的Bug解决

    网上搜索一遍,确实是Qt的Bug,需要重写,下面是一个网友实现的MyDoubleValidator类。

    • 定义MyDoubleValidator类
    class MyDoubleValidator : public QDoubleValidator
    {
        Q_OBJECT
    public:
        MyDoubleValidator(QObject *parent);
        ~MyDoubleValidator();
        virtual QValidator::State validate(QString &input, int &pos) const;
    };
    
    • 函数实现
    #include "MyDoubleValidator.h"
    
    MyDoubleValidator::MyDoubleValidator(QObject *parent)
        : QDoubleValidator(parent)
    {
    }
    
    MyDoubleValidator::~MyDoubleValidator()
    {
    }
    
    QValidator:: State MyDoubleValidator::validate(QString & input, int & pos) const
    {
        if (input.isEmpty())
        {
            return QValidator::Intermediate;
        }
        bool OK = false;
        double val = input.toDouble(&OK);
    
        if (!OK)
        {
            return QValidator::Invalid;
        }
    
        int dotPos = input.indexOf(".");
        if (dotPos > 0)
        {
            if (input.right(input.length() - dotPos - 1).length() > decimals())
            {
                return QValidator::Invalid;
            }
        }
        if(val<bottom()|| val>top())
            return QValidator::Invalid;
        return QValidator::Acceptable;
    }
    
    • 实际应用
    {
        MyDoubleValidator * dv = new  MyDoubleValidator(0);
        dv->setNotation(QDoubleValidator::StandardNotation);
        dv->setRange(2.0, 3.0, 2);
        ui.lineEdit->setValidator(dv); 
    }
    

    自定义函数的实现方式

    一开始,我并不知道可以通过setValidator函数来实现数据类型限制,我直接实现了一个检测输入的QString类型数据是否是Float数据,并没有指定小数后的位数,返回值为1表示是Float类型数据,否则不是。

    • 函数实现
    int Dialog::FloatCheck(QString float_str)
    {
        QByteArray ba = float_str.toLatin1();//QString 转换为 char*
        const char *str = ba.data();
    
        int dotNum = 0;
        int dotIdx = 0;
        int Idx = 0;
        while(*str)
        {
            Idx++;
            if(*str == '.')
            {
                dotIdx = Idx;   //dot
                dotNum++;       //dot个数统计
                if(dotNum > 1)  //小数点个数超过1
                    return 0;
                else if((dotNum == 0 && dotIdx) || (dotNum == 1 && dotIdx == 1))    //无小数点
                {
                    return 1;
                }
            }
            if(*str != '.')
            {
                if(*str < '0' || *str > '9')
                    return 0;
            }
            str++;
        }
        return 1;
    }
    
    • 测试验证
    /*
    
    输入:
        char *str1 = "1.2345";
        char *str2 = "a.2345";
        char *str3 = "0.2345";
        char *str4 = "1a2345";
        char *str5 = "a2345";
        char *str6 = "1.2.2345";
        char *str7 = "3.234.";
        char *str8 = "3.234.a";
    
    输出:
    
    str1 : 1.2345 - 1
    str2 : a.2345 - 0
    str3 : 0.2345 - 1
    str4 : 1a2345 - 0
    str5 : a2345 - 0
    str6 : 1.2.2345 - 0
    str7 : 3.234. - 0
    str8 : 3.234.a - 0
    
    */
    

    历史精选

    • Qt实现软件自动更新的一种简单方法
    • Qt小项目之串口助手控制LED
    • 真正的RISC-V开发板——VEGA织女星开发板开箱评测
    • 手把手教你制作Jlink-OB调试器(含原理图、PCB、外壳、固件)

    欢迎关注我的个人博客:www.wangchaochao.top

    或微信扫码关注我的公众号

    84271a86129d11153d3c304df2935e1d.png
    展开全文
  • 在介绍完 Objective-C 中的四大基本类型之一 int 类型 后,接下来不得提的就是 float 类型。声明为 float 类型的变量可存储包含... 125.8 -.0001 都是合法的浮点常量。要显示浮点值,可用 NSLog 转换字符 %
    在介绍完 Objective-C 中的四大基本类型之一 int
     类型 后,接下来不得不提的就是 float 类型。声明为 float 类型的变量可存储包含小数位的值。要区分浮点常量,可通过查看其是否包含小数点。可以省略小数点之前的数字,也可以省略之后的数字。然而,显然不能将它们全部省略。值
     3.  125.8  -.0001 都是合法的浮点常量。要显示浮点值,可用 NSLog 转换字符 %f

         浮点常量也能使用所谓的科学计数法来表示。值 1.7e4 就是使用这种计数法来表示的浮点值,它表示值 1.7*10 的 4 次方。位于字母 e 前的值称为尾数,而之后的值称为指数。指数前面可以放置正好或负号,指数表示将与尾数相乘的 10 的幂。因此,在常量 2.25e-3 中,2.25 是尾数值,而 -3 是指数值。该常量表示值 2.25*10 的 -3 次方,或 0.00225。BTW,用于分隔尾数和指数的字母 e,可用大写字母,也可用小写字母。

         要用科学计数法显示值,应该在 NSLog 格式字符串中指定格式字符 %e。使用 NSLog 格式字符串 %g 允许 NSLog 确定使用常用的浮点计数法还是使用科学计数法来显示浮点值。这一决定取决于指数的值:如果该值小于 -4 或大于 5,采用 %e (科学计数法)表示,否则采用 %f (浮点计数法)。

         十六进制的浮点常量包括前导的 0x 或 0X,后面紧跟一个或多个十进制或十六进制数字,再后是 p 或 P,最后是可以带负号的二进制指数。例如,0x0.3p10 表示的值为 3/16*2 的 10 次方 = 192。

    展开全文
  • 识别浮点常量问题

    2020-09-13 18:08:15
    输入一个小C语言源程序,源程序长度超过2000个字符,保证输入合法。 Output 按照源程序中单词出现顺序输出,输出二元组形式单词串。 (单词种类,单词) 单词一共5个种类: 关键字:用keyword表示 自定义标识符:...

    Pascal语言对浮点常量的语法要求是:一个浮点常量除了十进制数码之外,必须带有一个小数点或一个指数(紧接在字母e或E之后,在正式文档中也被称为比例因子)。如果该浮点常量含有小数点,则在小数点两侧都至少要有一个十进制数码。当然,在整个浮点常量或指数之前,也许会出现符号+或-。指数不能包含小数。空格也许会出现在浮点常量的前后,但不会出现在浮点常量中间。
    Input
    输入只有一行,就是有待识别的字符串。字符串的长度不超过255。
    Output
    请将分析的结果按以下样例的格式输出。如果输入文件中的字符串是Pascal浮点常量,请输出字符串“YES”,否则输出字符串“NO”。

    #include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
        string s;
        cin>>s;
    
        int i=0;
        if(s[i]=='+'||s[i]=='-'||(s[i]>='0'&&s[i]<='9'))
        {
            i++;
        }
        else
        {
            cout<<"NO"<<endl;
            return 0;
    
        }
    
        while(s[i]>='0'&&s[i]<='9')
        {
            i++;
        }
    
    
        if(s[i]=='.')
        {
    
            int i1=i-1,i2=i+1;
            if((s[i1]>='0'&&s[i1]<='9')&&(s[i2]>='0'&&s[i2]<='9'))
            {
                i++;
            }
            else
            {
                cout<<"NO"<<endl;
                return 0;
            }
            while((s[i]>='0'&&s[i]<='9'))
            {
                i++;
            }
            if(s[i]=='E'||s[i]=='e')
            {
                i++;
            }
            else if(s[i]=='\0')
            {
                cout<<"YES"<<endl;
                return 0;
            }
            else
            {
                cout<<"NO"<<endl;
                return 0;
            }
            if(s[i]=='+'||s[i]=='-'||(s[i]>='0'&&s[i]<='9'))
            {
                i++;
            }
            else
            {
                cout<<"NO"<<endl;
                return 0;
            }
            while((s[i]>='0'&&s[i]<='9'))
            {
                i++;
            }
            if(s[i]=='\0')
            {
                cout<<"YES"<<endl;
                return 0;
            }
            else
            {
                cout<<"NO"<<endl;
                return 0;
            }
        }
        else if(s[i]=='E'||s[i]=='e')
        {
            i++;
            if(s[i]=='+'||s[i]=='-'||(s[i]>='0'&&s[i]<='9'))
            {
                i++;
            }
            else
            {
                cout<<"NO"<<endl;
                return 0;
            }
            while((s[i]>='0'&&s[i]<='9'))
            {
                i++;
            }
            if(s[i]=='\0')
            {
                cout<<"YES"<<endl;
                return 0;
            }
            else
            {
                cout<<"NO"<<endl;
                return 0;
            }
        }
        else
        {
            cout<<"NO"<<endl;
            return 0;
        }
    
    
    }
    
    展开全文
  • 咋一看,在一个shell脚本中合法化一个浮点值的过程看起来有些挫,但想想看浮点数也不过就是一个用小数点分割开来2个整数。联系第5个脚本validint.sh,你会发现浮点数合法测试短让人惊讶。 代码: valid...

       咋一看,在一个shell脚本中合法化一个浮点值的过程看起来有些挫,但想想看浮点数也不过就是一个用小数点分割开来的2个整数。联系第5个脚本validint.sh,你会发现浮点数合法化的测试短的让人惊讶。

    代码:

    validfloat.sh
     1 #!/bin/sh
     2 
     3 # validfloat.sh -- 测试一个值是否是合法的浮点数
     4 # 注意,这个脚本并不能接受科学记数法形式的数字
     5 
     6 # 为了测试是否合法,我们需要在小数点位置分割数字。
     7 # 然后测试第一个部分,看看是不是一个合法的整数
     8 # 然后测试第二个,看看是不是>=0的整数。
     9 # 所以-30.5合法,-30.-8非法。
    10 
    11 source validint.sh
    12 
    13 validfloat()
    14 {
    15     fvalue="$1"
    16 
    17     if [ ! -z $(echo $fvalue | sed 's/[^.]//g') ]; then
    18         
    19         decimalPart="$(echo $fvalue | cut -d. -f1)"
    20         fractionalPart="$(echo $fvalue | cut -d. -f2)"
    21 
    22         if [ ! -z $decimalPart ]; then
    23             if ! validint "$decimalPart" "" ""; then
    24                 return 1
    25             fi
    26         fi
    27 
    28         if [ "${fractionalPart%${fractionalPart#?}}" = "-" ]; then
    29             echo "Invalid floating-point number: '-' not allowed \
    30 after decimal point" >&2
    31             return 1
    32         fi
    33 
    34         if [ "$fractionalPart" != "" ]; then
    35             if ! validint "$fractionalPart" "0" ""; then
    36                 return 1
    37             fi
    38         fi
    39 
    40         if [ "$decimalPart" = "-" -o -z "$decimalPart" ]; then
    41             if [ -z $fractionalPart ]; then
    42                 echo "Invalid floating-point format." >&2
    43             fi
    44         fi
    45 
    46     else
    47         if [ "$fvalue" = "-" ]; then
    48             echo "Invalid floating-point format." >&2
    49             return 1
    50         fi
    51 
    52         if ! validint "$fvalue" "" ""; then
    53             return 1
    54         fi
    55 
    56     fi
    57 
    58     return 0
    59 }
    60 
    61 if validfloat $1; then
    62     echo "$1 is a valid floating-point value"
    63 fi

    运行脚本:
    调用函数的时候,如果没有报错信息,返回码是0,给定的数字就是一个合法的浮点数。通过增加下面几行到脚本中来测试下:

    1 if validfloat $1; then
    2     echo "$1 is a valid floating-point value"
    3 fi

    运行结果:

     1 ./validfloat.sh 1234.56
     2 1234.56 is a valid floating-point value
     3 ./validfloat.sh -1234.56
     4 -1234.56 is a valid floating-point value
     5 ./validfloat.sh -.75
     6 -.75 is a valid floating-point value
     7 ./validfloat.sh -11.-12
     8 Invalid floating-point number: '-' not allowed after decimal point
     9 ./validfloat.sh 1.0344e22
    10 错误的数字格式!只有数字,不能有逗号、空格等

       在此提示下,在上面的脚本中用source引入validint.sh的时候,记得把validint中的最后几行测试脚本注释掉,否则会报错的。source的用法可具体参考手册页。

    分析脚本:
       对上面的脚本的最好的扩展就是让它支持科学记数法。就是最后一个测试的内容。这个并不是
    太难。你要测试下有没有'e'或'E',然后将结果分割为3个部分:
      小数点前的部分,只有一个数字;
      小数部分;
      指数部分。
       最后确保每个部分都是整数。
       老七我自己想了一会,写了一个,欢迎大家指正:

    测试科学记数法
     1 validfloat()
     2 {
     3     fvalue="$1"
     4     delimiter="$(echo $fvalue | sed 's/[^e|^E]//g')"
     5 
     6     if [ ! -z $delimiter ]; then    #测试下是否有e或E
     7 
     8         if [ ${#delimiter} -ne 1 ]; then    #e或E不能有多个
     9             echo "only one e or E."
    10             return 1
    11         fi
    12         
    13         decimalPart="$(echo $fvalue | cut -d. -f1)"                #小数点前部分
    14         part="$(echo $fvalue | cut -d. -f2-)"                    #小数点后部分,注意f2后有一小横,目的是输出剩下的所有域
    15         fractionalPart="$(echo $part | cut "-d$delimiter" -f1)"    #小数点后,e前部分
    16         exponent="$(echo $part | cut "-d$delimiter" -f2)"        #e后部分
    17 
    18         if ! validint "$decimalPart" "-9" "9"; then                #测试小数点前的部分是不是一个数字,即0-9范围内
    19             echo "scientific notation's decimal part abs must in [0-9]."
    20             return 1
    21         fi
    22 
    23         if [ "${fractionalPart%${fractionalPart#?}}" = '-' ]; then    #测试小数部分第一个符号是不是负号
    24             echo "scientific notation's fractional portion cannot be negative."
    25             return 1
    26         fi
    27 
    28         if [ "$fractionalPart" = "" ]; then    #测试小数部分是不是为空
    29             echo "scientific notation's fractional portion is empty."
    30             return 1
    31         else
    32             if ! validint "$fractionalPart" "" ""; then        #测试小数部分是不是整数
    33                 echo "scientific notation's fractional portion is not integer."
    34                 return 1
    35             fi
    36         fi
    37 
    38         if ! validint "$exponent" "" ""; then
    39             echo "scientific notation's exponent not integer."
    40             return 1
    41         fi
    42     
    43     elif [ ! -z $(echo $fvalue | sed 's/[^.]//g') ]; then

    下面的代码和上面的都一样了。然后测试下:

    1 ./validfloat2.sh 1.0EEe22    
    2 only one e or E.
    3 ./validfloat2.sh 1.-3E22
    4 scientific notation's fractional portion cannot be negative.
    5 /validfloat2.sh 1.34E-22.35
    6 错误的数字格式!只有数字,不能有逗号、空格等
    7 scientific notation's exponent not integer.
    8 ./validfloat2.sh 1.013E22
    9 1.013E22 is a valid floating-point value

    最后,整理下书上的,和自己写的:

    validfloatNew.sh
     1 #!/bin/sh
     2 
     3 source validint.sh
     4 
     5 validfloat()
     6 {
     7     fvalue="$1"
     8     delimiter="$(echo $fvalue | sed 's/[^e|^E]//g')"
     9 
    10     if [ ! -z $delimiter ]; then    #测试下是否有e或E
    11 
    12         if [ ${#delimiter} -ne 1 ]; then    #e或E不能有多个
    13             echo "only one e or E."
    14             return 1
    15         fi
    16         
    17         decimalPart="$(echo $fvalue | cut -d. -f1)"                #小数点前部分
    18         part="$(echo $fvalue | cut -d. -f2-)"                    #小数点后部分,注意f2后有一小横,目的是输出剩下的所有域
    19         fractionalPart="$(echo $part | cut "-d$delimiter" -f1)"    #小数点后,e前部分
    20         exponent="$(echo $part | cut "-d$delimiter" -f2)"        #e后部分
    21 
    22         if ! validint "$decimalPart" "-9" "9"; then                #测试小数点前的部分是不是一个数字,即0-9范围内
    23             echo "scientific notation's decimal part abs must in [0-9]."
    24             return 1
    25         fi
    26 
    27         if [ "${fractionalPart%${fractionalPart#?}}" = '-' ]; then    #测试小数部分第一个符号是不是负号
    28             echo "scientific notation's fractional portion cannot be negative."
    29             return 1
    30         fi
    31 
    32         if [ "$fractionalPart" = "" ]; then    #测试小数部分是不是为空
    33             echo "scientific notation's fractional portion is empty."
    34             return 1
    35         else
    36             if ! validint "$fractionalPart" "" ""; then        #测试小数部分是不是整数
    37                 echo "scientific notation's fractional portion is not integer."
    38                 return 1
    39             fi
    40         fi
    41 
    42         if ! validint "$exponent" "" ""; then
    43             echo "scientific notation's exponent not integer."
    44             return 1
    45         fi
    46     
    47     elif [ ! -z $(echo $fvalue | sed 's/[^.]//g') ]; then
    48         
    49         decimalPart="$(echo $fvalue | cut -d. -f1)"
    50         fractionalPart="$(echo $fvalue | cut -d. -f2)"
    51 
    52         if [ ! -z $decimalPart ]; then
    53             if ! validint "$decimalPart" "" ""; then
    54                 return 1
    55             fi
    56         fi
    57 
    58         if [ "${fractionalPart%${fractionalPart#?}}" = "-" ]; then
    59             echo "Invalid floating-point number: '-' not allowed \
    60 after decimal point" >&2
    61             return 1
    62         fi
    63 
    64         if [ "$fractionalPart" != "" ]; then
    65             if ! validint "$fractionalPart" "0" ""; then
    66                 return 1
    67             fi
    68         fi
    69 
    70         if [ "$decimalPart" = "-" -o -z "$decimalPart" ]; then
    71             if [ -z $fractionalPart ]; then
    72                 echo "Invalid floating-point format." >&2
    73             fi
    74         fi
    75 
    76     else
    77         if [ "$fvalue" = "-" ]; then
    78             echo "Invalid floating-point format." >&2
    79             return 1
    80         fi
    81 
    82         if ! validint "$fvalue" "" ""; then
    83             return 1
    84         fi
    85 
    86     fi
    87 
    88     return 0
    89 }
    90 
    91 if validfloat $1; then
    92     echo "$1 is a valid floating-point value"
    93 fi

     

     

     

     

     

     

     

     

     

     

    转载于:https://www.cnblogs.com/lalala23456/archive/2012/12/06/2804562.html

    展开全文
  • 常量可以是任何基本数据类型,可分为整型数字、浮点数字、字符、字符串和布尔。常量就像是常规变量,只不过常量的值在定义后能进行修改。整数常量整数常量可以是十进制、八进制或十六进制常量。前缀指定...
  • PAT 1054 求平均

    2020-03-13 18:02:15
    吐槽:初看题目描述(未看例子前)想着这题...也因为有非数字所以在定义时,就能定义为浮点型。若仍定义浮点型,而输入是非数字,则会处理为0(如图所示)。 因此,将其定义为string类型,判断字符串中每个字...
  • 详解C++中常量

    2021-01-21 15:25:53
    常量是固定,在程序执行期间不会改变。这些固定的,又叫做字面量。 常量可以是任何的基本数据类型,可分为整型数字、浮点数字、字符、字符串和布尔。 常量就像是常规的变量,只不过常量的在...212 // 合法的
  • 常量是固定,在程序执行期间不会改变。这些固定的,又叫做字面量。 常量可以是任何的基本数据类型,可分为整型数字、浮点数字、字符、字符串和布尔。 常量就像是常规的变量,只不过常量的...212 // 合法的 215u
  • 1. C的数据类型 C的数据类型包括:整型、字符型、实型或浮点型(单...否则为不合法的变量名。变量在编译时为其分配相应存储单元。符号常量:用一个标识符代表一个常量,定义符号常量又称为“宏定义”,一般写在程...
  • 最近在和同行聊的时候,聊起数据库存储字段的类型区别时候发现有些字段自己也不是很...最大的合法的显示尺寸是 255 。D适用于浮点类型并且指出跟随在十进制小数点后的数码的数量。最大可能的是30,但是应该大于M...
  • 最大的合法的显示尺寸是 255 。 D 适用于浮点类型并且指出跟随在十进制小数点后的数码的数量。最大可能的是30,但是应该大于M-2。 方括号(“[”和“]”)指出可选的类型修饰符的部分。 注意,如果你指定一个了为...
  • 最大的合法的显示尺寸是 255 。D适用于浮点类型并且指出跟随在十进制小数点后的数码的数量。最大可能的是30,但是应该大于M-2。方括号(“[”和“]”)指出可选的类型修饰符的部分。注意,如果你指定一个了为...
  • 如果一个全局变量初始为“零”,它可否作为空指针或浮点零? 1.32 下面代码为什么能编译?intf(){chara[]="Hello,world!";} *1.33 下面初始化有什么问题?编译器提示“invalidinitializers”或其他信息。...
  • Mysql 支持数据类型

    2010-05-28 09:19:48
    最大的合法的显示尺寸是 255 。 D 适用于浮点类型并且指出跟随在十进制小数点后的数码的数量。最大可能的是30,但是应该大于M-2。 方括号(“[”和“]”)指出可选的类型修饰符的部分。 注意,如果你...
  • 修饰符类型: 无符号 有符号 long short 常量:是指在运行过程中,变化的。...234ul //无符号长整型(u和L的大小写与位置都可以互换) ...布尔常量:只有两个。...3.14159 // 合法的 314159E
  • 1. 输入的是字符串,如果该字符串是类似“123”,“34.19”,“1e3”这样的有明确数值的,input()是可以读取的,但是它会计算字符串的,读取的其实是整型和浮点型,如果是“33ff”,“444.e”这样不合法的字符串是...
  • 这样是合法的和可移植的吗? 23  2.8 我听说结构可以赋给变量也可以对函数传入和传出。为什么K&R1却明确说明能这样做? 25 2.9 为什么能用内建的==和!=操作符比较结构? 26 2.10 结构传递和返回是如何实现...
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    这样是合法的和可移植的吗? 23  2.8 我听说结构可以赋给变量也可以对函数传入和传出。为什么K&R1却明确说明能这样做? 25 2.9 为什么能用内建的==和!=操作符比较结构? 26 2.10 结构传递和返回是如何实现...
  • 这样是合法的和可移植的吗? 2.8 我听说结构可以赋给变量也可以对函数传入和传出。为什么K&R1;却明确说明能这样做? 2.9 为什么能用内建的==和!=操作符比较结构? 2.10 结构传递和返回是如何实现的? 2.11 如何...
  • 如果一个全局变量初始为“零”,它可否作为空指针或浮点零?  1.32 下面代码为什么能编译?intf(){chara[]="Hello,world!";}  *1.33 下面初始化有什么问题?编译器提示“invalidinitializers”或其他信息...
  • 如果一个全局变量初始为“零”,它可否作为空指针或浮点零? 1.32 下面代码为什么能编译?intf(){chara[]="Hello,world!";} *1.33 下面初始化有什么问题?编译器提示“invalidinitializers”或其他信息。...
  • 这样是合法的和可移植的吗? 52 2.8 我听说结构可以赋给变量也可以对函数传入和传出。为什么K&R1;却明确说明能这样做? 54 2.9 为什么能用内建的==和!=操作符比较结构? 55 2.10 结构传递和返回是如何实现的...
  • 这样是合法的和可移植的吗? 2.8 我听说结构可以赋给变量也可以对函数传入和传出。为什么K&R1却明确说明能这样做? 2.9 为什么能用内建的==和!=操作符比较结构? 2.10 结构传递和返回是如何实现的? 2.11 如何向...
  • C++(3)_常量

    2020-07-16 18:27:51
    常量可以是任何基本数据类型,可分为整型数字、浮点数字、字符、字符串和布尔。 常量就像是常规变量,只不过常量的值在定义后能进行修改。 整型常量 整数常量可以是十进制、八进制或十六进制常量。 前缀...
  • 你必须知道495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    3.10 如果我使用表达式的值, 我应该用++i 或i++ 来自增一个变量 吗? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 3.11 为什么如下代码int a = 100, b = 100; long int c = a * b;...
  • mysql 字段类型说明

    2020-12-17 17:31:08
    最大的合法的显示尺寸是 255 。 D 适用于浮点类型并且指出跟随在十进制小数点后的数码的数量。最大可能的是30,但是应该大于M-2。 方括号(“[”和“]”)指出可选的类型修饰符的部分。 注意,如果你指定一个了...
  • 6、mysql数据类型介绍

    2019-10-03 02:53:34
    MySQL数据类型,可以被分为3类:数值类型、日期和时间...最大的合法的显示尺寸是 255 。 D 适用于浮点类型并且指出跟随在十进制小数点后的数码的数量。最大可能的是30,但是应该大于M-2。 UNSIGNED ...
  • Mysql常用数据类型

    2020-03-11 15:05:20
    Mysql常用数据类型 ...最大的合法的显示尺寸是 255 。 D 适用于浮点类型并且指出跟随在十进制小数点后的数码的数量。最大可能的是30,但是应该大于M-2。 UNSIGNED 为“无符号”的意思, 即...

空空如也

空空如也

1 2 3 4 5
收藏数 88
精华内容 35
关键字:

不合法的浮点值