精华内容
下载资源
问答
  • double浮点数字符串算法

    千次阅读 2014-03-18 14:07:25
    之前写过一个,浮点数字符串类型时,需要一个变量,指定小数点后几位,也就是有效位。 一般情况下为6位,当前大部分编译环境都是这样的。 所以我的实现方式是 1:对浮点数取证,方法很简单把浮点数强制转化为...

    http://www.phpfans.net/ask/quiz1/44371008768.html


    vc中可以用 sprintf(str,"%f",f); 实现;
    之前写过一个,浮点数转字符串类型时,需要一个变量,指定小数点后几位,也就是有效位。
    一般情况下为6位,当前大部分编译环境都是这样的。

    所以我的实现方式是
    1:对浮点数取证,方法很简单把浮点数强制转化为整形。
    2:把这个整形转化为字符串类型(可以使用itoa方法,当然也可以自己辗转/10取得)
    3:把上面的得到的数放入字符数组中,在最后一位加上字符"."
    4:使用浮点数减去上面得到的整数得到一个0.xxxx的浮点数
    5:使用这个浮点数乘以10^6(有效位的方)得到一个浮点性
    6:再次执行1,2步
    7:把两次得到的字符串连接起来就可以

    具体实现过程中,有几点需要注意
    1:需要判断浮点数的正负关系,负数也是执行上述过程,只是在最后输出的字符串上加上"-"
    2:在实现过程中第四部的减会损失部分误差,可以对原浮点数直接乘10^6减去 整数乘10^6得到数取整。

    STL的具体实现中也是使用类似方法,关于这个问题,记得1年前和奶油狗争论过,可以参考那片贴子。
    ---------------------------------------------------------------------------------------------------------------------------------------
    ---------------------------------------------------------------------------------------------------------------------------------------
    小时候(不见得多小,吼吼)写过类似的一篇文章,发表在CSDN的专栏上。现在看起来简直粗陋无比,因此萌发了重写的念头。   

    众所周知,计算机中的所有数据都是以二进制表示的,浮点数也不例外。然而浮点数的二进制表示法却不像定点数那么简单了。   

    先澄清一个概念,浮点数并不一定等于小数,定点数也并不一定就是整数。所谓浮点数就是小数点在逻辑上是不固定的,而定点数只能表示小数点固定的数值,具用 浮点数或定点数表示某哪一种数要看用户赋予了这个数的意义是什么。   

    C++中的浮点数有6种,分别是:   

    float:单精度,32位   
    unsigned float:单精度无符号,32位   
    double:双精度,64位   
    unsigned double:双精度无符号,64位   
    long double:高双精度,80位   
    unsigned long double:高双精度无符号,80位(嚯,应该是C++中最长的内置类型了吧!)   

    然而不同的编译器对它们的支持也略有不同,据我所知,很多编译器都没有按照IEEE规定的标准80位支持后两种浮点数的,大多数编译器将它们视为 double,或许还有极个别的编译器将它们视为128位?!对于128位的long double我也仅是听说过,没有求证,哪位高人知道这一细节烦劳告知。   

    下面我仅以float(带符号,单精度,32位)类型的浮点数说明C++中的浮点数是如何在内存中表示的。先讲一下基础知识,纯小数的二进制表示。(纯小 数就是没有整数部分的小数,讲给小学没好好学的人)   

    纯小数要想用二进制表示,必须先进行规格化,即化为 1.xxxxx * ( 2 ^ n ) 的形式(“^”代表乘方,2 ^ n表示2的n次方)。对于一个纯小数D,求n的公式如下:   
    n = 1 + log2(D); // 纯小数求得的n必为负数   
    再用 D / ( 2 ^ n ) 就可以得到规格化后的小数了。接下来就是十进制到二进制的转化问题,为了更好的理解,先来看一下10进制的纯小数是怎么表示的,假设有纯小数D,它小数点 后的每一位数字按顺序形成一个集合:   
    {k1, k2, k3, ... , kn}   
    那么D又可以这样表示:   
    D = k1 / (10 ^ 1 ) + k2 / (10 ^ 2 ) + k3 / (10 ^ 3 ) + ... + kn / (10 ^ n )   
    推广到二进制中,纯小数的表示法即为:   
    D = b1 / (2 ^ 1 ) + b2 / (2 ^ 2 ) + b3 / (2 ^ 3 ) + ... + bn / (2 ^ n )   
    现在问题就是怎样求得b1, b2, b3,……,bn。算法描述起来比较复杂,还是用数字来说话吧。声明一下,1 / ( 2 ^ n )这个数比较特殊,我称之为位阶值。   
    例如0.456,第1位,0.456小于位阶值0.5故为0;第2位,0.456大于位阶值0.25,该位为1,并将0.45减去0.25得0.206进 下一位;第3位,0.206大于位阶值0.125,该位为1,并将0.206减去0.125得0.081进下一位;第4位,0.081大于0.0625, 为1,并将0.081减去0.0625得0.0185进下一位;第5位0.0185小于0.03125……   
    最后把计算得到的足够多的1和0按位顺序组合起来,就得到了一个比较精确的用二进制表示的纯小数了,同时精度问题也就由此产生,许多数都是无法在有限的n 内完全精确的表示出来的,我们只能利用更大的n值来更精确的表示这个数,这就是为什么在许多领域,程序员都更喜欢用double而不是float。   

    float的内存结构,我用一个带位域的结构体描述如下:   
    struct MYFLOAT   
    {   
    bool bSign : 1; // 符号,表示正负,1位   
    char cExponent : 8; // 指数,8位   
    unsigned long ulMantissa : 23; // 尾数,23位   
    };   

    符号就不用多说了,1表示负,0表示正   
    指数是以2为底的,范围是 -128 到 127,实际数据中的指数是原始指数加上127得到的,如果超过了127,则从-128开始计,其行为和X86架构的CPU处理加减法的溢出是一样的。比 如:127 + 2 = -127;127 - 2 = 127   
    尾数都省去了第1位的1,所以在还原时要先在第一位加上1。它可能包含整数和纯小数两部分,也可能只包含其中一部分,视数字大小而定。对于带有整数部分的 浮点数,其整数的表示法有两种,当整数大于十进制的16777215时使用的是科学计数法,如果小于或等于则直接采用一般的二进制表示法。科学计数法和小 数的表示法是一样的。   
    小数部分则是直接使用科学计数法,但形式不是X * ( 10 ^ n ),而是X * ( 2 ^ n )。拆开来看。   

    0 00000000 0000000000000000000000   
    符号位 指数位 尾数位   


    下面是一个分析float类型内存数据的程序,经测试是完好的,如果发现有问题,请提出来,我好改进。


    #include <iostream>   
    #include <iomanip>   
    using namespace std;   

    int _tmain( int argc, _TCHAR* argv[] )   
    {   
    // 有符号的32位float类型浮点数变量的定义及数据初始化,其值可任意修改   
    float fDigital = 0.0f;   
    // 临时变量,用于存储浮点数的内存数据   
    unsigned long nMem;   
    // 将内存按位复制到临时变中,以便取用。   
    nMem = *(unsigned long*)&fDigital;   

    // 以小数点后保留8个小数点的精度输出原始浮点数   
    cout << setprecision( 8 );   
    cout << "浮点数:" << fDigital << endl;   
    cout << "-----------------------" << endl;   

    // 判断是否为0,全部位都为0的浮点数据表示0,无分析意义   
    if ( nMem != 0 )   
    {   
    // 打印出其符号。   
    // 最高1位为符号位。用bool来表示,true表示负数,false表示正数。   
    // 和最高位为1的数据0x80000000进行按位与,可得到其符号。   
    bool bNegative = ( ( nMem & 0x80000000L ) != 0 );   
    // 如果是负数,则输入负号,否则输出空格。   
    cout << "符号:" << ( bNegative ? '-' : '+' ) << endl;   

    // 打印出其指数。   
    // 第30 - 23位是指数位,是有正负的8位整数数据,用char来表示。   
    // 将内存右移一位,再左移24位,再硬性截断为8位即可得到指数原始数据。   
    char cExponent = (char)( ( nMem << 1 ) >> 24 );   
    // IEEE浮点数表示法规定,原指数加127为内存中的指数。   
    // 将原始指数数据减127得到其真实指数(CPU会自动处理上下界溢出)。   
    cExponent -= 127;   
    // 以10进制带符号整数方式输出指数数据   
    cout << "指数:" << (int)cExponent << endl;   

    // 打印出其尾数。   
    // 第22 - 0位是尾数位,由于省去了头一位1,因此应该是24位无符号数据。   
    // 用无符号长整型来表示。   
    // 和最低22位都是1的数据0x7FFFFF进行按位与,可得到尾数原始数据   
    unsigned long ulMantissa = ( nMem & 0x7FFFFFL );   
    // 和第23位是1的数据0x800000进行按位或,可补齐省去的最高位1   
    ulMantissa |= 0x800000L;   
    // 以16进制整数方式输出尾数数据   
    cout << "尾数:0x" << setbase( 16 ) << setfill( '0' ) << setw( 8 );   
    cout << setiosflags( ios_base::uppercase ) << ulMantissa << endl;   

    // 完全基于整型算法来实现二进制小数到整数的转换极其复杂,   
    // 这里借用double简单实现,仅说明其理论。详细算法见说明。   
    // 计算出浮点数的整数部分,用双精度型表示   
    double dInteger = 0;   
    // 指数大于或等于0就代表尾数中存在整数部分   
    if ( cExponent >= 0 )   
    {   
    // 如果指数大于23,则说明整数部分以科学计数法表示   
    if ( cExponent > 23 )   
    {   
    // dCurBit用来计算和存储循环中对于每一位的位阶数   
    double dCurBit = 1.0;   
    // 循环所有位,计算科学计数法中的小数的十进制形式   
    for ( int nBitIdx = 0; nBitIdx < 24; nBitIdx++ )   
    {   
    // 将整数部分左移当前位加9,将当前位置于最高位;   
    // 再右移31位可得当前位,再用当前位阶乘以该位,   
    // 即得累加数。累加计入二进制小数。   
    dInteger += dCurBit * ( ( ulMantissa <<   
    ( 8 + nBitIdx ) ) >> 31 );   
    // 由当前位阶除以2得到下次位阶。   
    dCurBit /= 2;   
    }   
    // 将二进制表示的科学计数法转换为10进制   
    dInteger *= pow( 2.0, (double)cExponent );   
    }   
    else   
    {   
    // 将尾数右移小数部分的长度,即可得到整数部分   
    int nRightShift = 0;   
    // 如果指数小于23,则说明存在小数部分,需要右移   
    if ( cExponent < 23 )   
    {   
    // 尾数的原始长度减去指数即为小数部分长度   
    nRightShift = 23 - cExponent;   
    }   
    // 将尾数数据右移小数部分的长度,可得到整数部分。   
    dInteger = (double)( ulMantissa >> nRightShift );   
    }   
    }   
    // 以10进制无符号整数方式输出整数部分   
    cout << "整数部分:" << setbase( 10 ) << setprecision( 8 );   
    cout << dInteger << endl;   

    // 计算出浮点数的小数部分,用无符号长整型表示   
    double dDecimal = 0;   
    // 如果指数小于23,则尾数中含小数部分   
    if ( cExponent < 23 )   
    {   
    // 指数与23的差就是小数部分的长度,详见整数部分的处理。   
    // 将所有位均为1的32位整数右移32减小数部分长度,即指数加9,   
    // 可得到用于取得小数部分的mask数。   
    unsigned long ulDecimalMask = 0xFFFFFFFF;   
    // 如果指数大于或等于0就代表尾数中存在整数部分   
    if ( cExponent >= 0 )   
    {   
    ulDecimalMask >>= ( 9 + cExponent );   
    }   
    else   
    {   
    // 如果是纯小数,则必须恢复规格化时删掉的整数1   
    dDecimal = 1.0;   
    }   
    // 将尾数和mask数进行按位与,可得到小数部分   
    // 二进制小数用无符号长整型表示   
    unsigned long ulDecimal = ulMantissa & ulDecimalMask;   
    // dCurBit用来计算和存储循环中对于每一位的位阶数   
    double dCurBit = 0.5;   
    // 循环所有位,计算科学计数法中的小数的十进制形式   
    for ( int nBitIdx = 1; nBitIdx < 24; nBitIdx++ )   
    {   
    // 将二进制小数左移当前位加9,将当前位置于最高位;   
    // 再右移31位可得当前位。   
    // 用dCurBit乘以当前位,即得累加数。累加计入dDecimal。   
    dDecimal += dCurBit * ( ( ulDecimal <<   
    ( 8 + nBitIdx ) ) >> 31 );   
    // 由当前位阶除以2得到下次位阶。   
    dCurBit /= 2;   
    }   
    // 将二进制表示的科学计数法转换为10进制   
    dDecimal *= pow( 2.0, (double)cExponent );   
    }   
    // 以10进制无符号整数方式输出小数部分   
    cout << "小数部分:" << setbase( 10 ) << setprecision( 8 );   
    cout << dDecimal << endl;   
    }   
    else   
    {   
    cout << "浮点数为0,无分析意义" << endl;   
    }   

    cout << "-----------------------" << endl;   
    cout << "分析完毕,程序退出。" << endl << endl;   



    不可改动//   
    system( "pause" );   
    // _CrtDumpMemoryLeaks();   
    return 0;   
    不可改动//   

    }

    展开全文
  • 1. 判断是否是浮点数格式 2. 适用 前端传送浮点数字符串 判断 public boolean isNumber(String str){ String reg = "^[0-9]+(.[0-9]+)?$"; return str.matches(reg); }
    
     1. 判断是否是浮点数格式
     2. 适用 前端传送浮点数字符串 判断
    
    public boolean isNumber(String str){
            String reg = "^[0-9]+(.[0-9]+)?$";
            return str.matches(reg);
        }
    
    展开全文
  • type(Object) 求某个对象Object的类型 int(3.14)=3,float(3)=3.0 浮点数和整数转换 id(Object) 求某个对象的内存地址 **help(Object)**查看某个对象的帮助文档 函数也是对象 **dir(module)**查看某个模块的内置函数 ...

    python是弱类型语言

    Python、JavaScript、PHP 等脚本语言一般都是弱类型的
    强类型的编程语言中,定义变量时要指明变量的类型,而且赋值的数据也必须是相同类型的,C语言、C++、Java 是强类型语言的代表。

    弱类型语言有两个特点:
    变量无须声明就可以直接赋值,对一个不存在的变量赋值就相当于定义了一个新变量。
    变量的数据类型可以随时改变,如同一个变量可以一会儿被赋值为整数,一会儿被赋值为字符串。

    需要注意
    弱类型并不等于没有类型,弱类型是说在书写代码时不用刻意关注类型,但是在编程语言的内部仍然是有类型的。我们可以使用 type() 内置函数类检测某个变量或者表达式的类型

    如求两个力的合力
    在这里插入图片描述

    一、整数int和浮点数float

    type(Object) 求某个对象Object的类型 int(3.14)=3,float(3)=3.0 浮点数和整数转换
    id(Object) 求某个对象的内存地址

    **help(Object)**查看某个对象的帮助文档 函数也是对象
    **dir(module)**查看某个模块的内置函数 查看之前先import modue
    同样查看某个对象(如字符串str)的方法 **help(Object.function)**不能直接help(function)
    在这里插入图片描述
    在这里插入图片描述

    a*b乘法
    a**b幂次运算a^b
    a / b 除法 结果就是多少 不会取整
    a // b除法取整
    a%b 除法取余
    round(number,ndigits=None) 四舍五入类型不变 ndigits=None或者没有保留整型
    存在精度问题 round(1.2345,3)=1.234 没有四舍五入这里

    import decimal模块解决精度问题
    在这里插入图片描述

    divmod(num1,num2)求num1/num2,num1%num2 divmod(5,2)=(2,1)
    在这里插入图片描述
    python整数int永远不会有溢出问题 但是浮点数float会有
    在这里插入图片描述

    二、字符和字符串str

    单引号双引号都有可以

    ord(char)求字符的ASCII码 ord(‘a’)=97

    bin(num)整数转二进制不可以是小数

    int(‘numstring’)数字字符串转整型 int(‘250’)
    str(num) 数字(整型浮点型都可以)转字符串str
    chr(charNum) 数字转字母(对应ASCII码的数字) chr(ord(‘a’))=‘a’
    在这里插入图片描述
    ch.lower() 大写转小写
    ch.upper()小写转大写
    ch.isupper()判断是否是小写
    ch.islower()判断是否是小写

    str.lower()将字符串中的所有大写字母转换为小写字母,转换完成后,该方法会返回新得到的字符串。如果字符串中原本就都是小写字母,则该方法会返回原字符串。
    title() 将字符串中
    每个单词的首字母转为大写,其他字母全部转为小写
    ,转换完成后,此方法会返回转换得到的字符串。如果字符串中没有需要被转换的字符,此方法会将字符串原封不动地返回。
    ;
    import sys
    sys.getdefaultencoding()
    查看电脑默认使用编码

    1、序列及其基本操作

    + 同类型拼接
    在这里插入图片描述
    * 重复元素
    len()求长度
    in 判断字符/字符串是否在字符串中
    在这里插入图片描述

    2.索引和切片
    索引从左往右0开始编号 也可以从右往左-1开始编号

    切片 r[ [first]: [end]: [stride]]

    从first到end的半开半闭
    stride是步长 没有时默认步长为1 步长为正从左往右切 为负从右往左
    first没有默认从0开始取
    end没有默认到最后一个字符(包括最后一个)

    得到的切片是一个新的字符串,原字符串依然没变

    r[2:2]得到空串
    r[2:] 2到最后
    r[:9] 0到9
    r[2: 9: 2] 2到9 隔一个取一个
    r[:9:2] 0到9 隔一个取一个
    r[2::3] 2到最后隔两个取一个
    r[::3] 0到最后隔两个取一个
    r[:] 、r[::]得到的都是整个字符串
    r[::-1] 从右往左全部字符串 相当于把字符串逆序

    r[-10:8:2] r[-10]对应y r[8]对应b 步长为正 从左往右y->o得到"yhnb" 包括了b
    r[8:-10:-2] r[8]对应第一个o r[-10]对应y 步长为负 从右往左y<-o 得到"o ot"
    不能写成r[-10:8:-2] o<-y这样得到的是空串

    不管从左往右还是从右往左,
    先遇到的那个字符的索引做first
    后遇到的那个字符的索引做end,
    若开始字符和结束字符按照方向得不到就是空串

    在这里插入图片描述
    以上序列的基本操作和索引序列的基本操作对所有序列都成立 不只是对字符串 字符串只是序列的一种

    三、字符串str的常用属性和方法

    dir(Object) + help或者先定义一个对象实例再dir(实例)
    查看某个对象(如字符串str)的方法 **help(Object.function)**不能直接help(function)
    在这里插入图片描述
    常用的有:
    s.salnum() 字母或数字(正整数
    s.isdigit() 正整数
    s.isnumreic() 正整数
    s.isalpha() 纯字母
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    count():str.count(sub[,start[,end]])统计字符串出现的次数

    str.find(sub[,start[,end]]) 则返回第一次出现该字符串的索引;反之,则返回 -1
    str.index(sub[, start[, end]]) -> int
    返回字符串中sub串首次出现的开始下标 可以指定sub的某一段

    与find的不同之处在于,当指定的字符串不存在时,index() 方法会抛出异常。

    str.startswith(sub[,start[,end]])用于检索字符串是否以指定字符串开头,是返回 True;反之False
    endwith()

    split(self, /, sep=None, maxsplit=-1)
    将一个字符串按照指定的分隔符切分成多个子串,这些子串会被保存到列表中(不包含分隔符),作为方法的返回值反馈回来
    ,即返回字符串中以sep为分隔符得到的单词列表list若没有参数sep 默认按空格分隔

    maxsplit:可选参数用于指定分割的次数,最后列表中子串的个数最多为 maxsplit+1。如果不指定或者指定为 -1,则表示分割次数没有限制。
    在 split 方法中,如果不指定 sep 参数,那么也不能指定 maxsplit 参数。
    在未指定 sep 参数时,split() 方法默认采用空格进行分割,但当字符串中有连续的空格或其他空字符时,都会被视为一个分隔符对字符串进行分割
    在这里插入图片描述
    join(self, iterable, /) 将列表(或元组)中包含的多个字符串采用固定连接符连接成一个字符串。
    将一个字符串列表/元组中的各个字符串(单词)组装成以self为连接字符(串)的新的一个字符串

    newstr = str.join(iterable)
    此方法中各参数的含义如下:
    newstr:表示合并后生成的新字符串;
    str:用于指定合并时的分隔符;
    iterable:做合并操作的源字符串数据,允许以列表、元组等形式提供
    在这里插入图片描述

    去除字符串中空格(删除指定字符)的3种方法(http://c.biancheng.net/view/2180.html)
    strip():删除字符串前后(左右两侧)的空格或特殊字符。
    lstrip():删除字符串前面(左边)的空格或特殊字符。
    rstrip():删除字符串后面(右边)的空格或特殊字符。

    不指定参数删除空格制表符换行符回车符等特殊字符,也可手动指定
    Python 的 str 是不可变的(不可变的意思是指,字符串一旦形成,它所包含的字符序列就不能发生任何改变),因此这三个方法只是返回字符串前面或后面空白被删除之后的副本,并不会改变字符串本身。

    字符串拼接
    常量拼接 strname = “str1” “str2” 如s=“python” “java”
    变量拼接+
    数字拼接 不允许数字直接与字符串拼接,需要先将数字通过str()转成字符串 s=s1+str(num)

    字符串格式化输出
    S.format(*args, **kwargs) -> str
    相当于是用format里面的参数(数字字符均可)填空到S中
    在这里插入图片描述
    还可以规定插入参数的格式,如
    占位长度{0:10}占10位,
    对齐方式{1:>15}占15 位右对齐
    在数字类型、精度{0: .1f}保留一位小数 {1:4d}占4位且为整数

    注意中括号里面的0、1代表的是参数列表里面序号

    展开全文
  • 浮点数字符串转换成浮点数实现

    千次阅读 2014-11-24 12:59:18
    之前面试的时候,常给面试者出的一个面试题目是,给定一个字符串,输出该字符串表示的浮点数的值,要求如下:  写一个转换函数,该函数的输入是一个表示浮点数字符串,把该字符串转换成浮点数并输出。条件:请...

            之前面试的时候,常给面试者出的一个面试题目是,给定一个字符串,输出该字符串表示的浮点数的值,要求如下:

            写一个转换函数,该函数的输入是一个表示浮点数的字符串,把该字符串转换成浮点数并输出。条件:请考虑各种情况,并且代码中的循环尽量少,不能调用API或者crt库中的函数。例如:输入字符串"345.7",则输出浮点数345.7。接口可以为:float StrToFloatA(TCHAR* pstrfloat);

            没想到完全做对这个题目的人居然不多(上机笔试,函数写好之后丢到测试机里面跑一下看是否完全正确),因此自己在空闲时间实现了一下,确实还是有一点难度的。代码如下:

    1. /* ------------------------------------------------------------------------- 
    2. //  文件名     :   StringToFloat.h 
    3. //  创建者     :   magictong 
    4. //  创建时间    :   2011-9-6 14:14:25 
    5. //  功能描述    :    
    6. // 
    7. //  $Id: $ 
    8. // -----------------------------------------------------------------------*/  
    9. #ifndef __STRINGTOFLOAT_H__  
    10. #define __STRINGTOFLOAT_H__  
    11.   
    12. // -------------------------------------------------------------------------  
    13. float StrToFloatW(wchar_t* pstrfloat);  
    14. float StrToFloatA(char* pstrfloat);  
    15.   
    16. #if defined(UNICODE) || defined(_UNICODE)  
    17.     #define StrToFloat  StrToFloatW  
    18. #else  
    19.     #define StrToFloat  StrToFloatA  
    20. #endif // !UNICODE  
    21. // -------------------------------------------------------------------------  
    22. // $Log: $  
    23.   
    24. #endif /* __STRINGTOFLOAT_H__ */  


    1. /* ------------------------------------------------------------------------- 
    2. //  文件名     :   StringToFloat.cpp 
    3. //  创建者     :   magictong 
    4. //  创建时间    :   2011-9-6 14:14:02 
    5. //  功能描述    :    
    6. // 
    7. //  $Id: $ 
    8. // -----------------------------------------------------------------------*/  
    9.   
    10. #include "stdafx.h"  
    11. #include "StringToFloat.h"  
    12.   
    13. // -------------------------------------------------------------------------  
    14.   
    15. #pragma warning(disable:4244)  
    16. // -------------------------------------------------------------------------  
    17. // 函数       : StrToFloatA  
    18. // 功能       : 将一个字符串转换为浮点数  
    19. // 返回值  : float   
    20. // 参数       : char* pstrfloat  
    21. // 附注       :   
    22. // -------------------------------------------------------------------------  
    23. float StrToFloatA(char* pstrfloat)  
    24. {  
    25.     // check  
    26.     if (!pstrfloat)  
    27.     {  
    28.         return 0.0;  
    29.     }  
    30.   
    31.     bool bNegative = false;  
    32.     bool bDec = false;  
    33.   
    34.     char* pSor = 0;  
    35.     char chByte = '0';  
    36.     float fInteger = 0.0;  
    37.     float fDecimal = 0.0;  
    38.     float fDecPower = 0.1f;  
    39.   
    40.     // 进行首位判断,判断是否是负数  
    41.     if (pstrfloat[0] == '-')  
    42.     {  
    43.         bNegative = true;  
    44.         pSor = pstrfloat + 1;  
    45.     }  
    46.     else  
    47.     {  
    48.         bNegative = false;  
    49.         pSor = pstrfloat;  
    50.     }  
    51.   
    52.     while (*pSor != '\0')  
    53.     {  
    54.         chByte = *pSor;  
    55.   
    56.         if (bDec)  
    57.         {  
    58.             // 小数  
    59.             if (chByte >= '0' && chByte <= '9')  
    60.             {  
    61.                 fDecimal += (chByte - '0') * fDecPower;  
    62.                 fDecPower = fDecPower * 0.1;  
    63.             }  
    64.             else  
    65.             {  
    66.                 return (bNegative? -(fInteger +  fDecimal): fInteger + fDecimal);  
    67.             }  
    68.         }  
    69.         else  
    70.         {  
    71.             // 整数  
    72.             if (chByte >= '0' && chByte <= '9')  
    73.             {  
    74.                 fInteger = fInteger * 10.0 + chByte - '0';  
    75.             }  
    76.             else if (chByte == '.')  
    77.             {  
    78.                 bDec = true;  
    79.             }  
    80.             else  
    81.             {  
    82.                 return (bNegative? -fInteger : fInteger);  
    83.             }  
    84.         }  
    85.   
    86.         pSor++;  
    87.     }  
    88.   
    89.     return (bNegative? -(fInteger +  fDecimal): fInteger + fDecimal);  
    90. }  
    91.   
    92. // -------------------------------------------------------------------------  
    93. // 函数       : StrToFloatW  
    94. // 功能       : 将一个字符串转换为浮点数  
    95. // 返回值  : float   
    96. // 参数       : char* pstrfloat  
    97. // 附注       :   
    98. // -------------------------------------------------------------------------  
    99. float StrToFloatW(wchar_t* pstrfloat)  
    100. {  
    101.     // check  
    102.     if (!pstrfloat)  
    103.     {  
    104.         return 0.0;  
    105.     }  
    106.   
    107.     bool bNegative = false;  
    108.     bool bDec = false;  
    109.   
    110.     wchar_t* pSor = 0;  
    111.     wchar_t chByte = L'0';  
    112.     float fInteger = 0.0;  
    113.     float fDecimal = 0.0;  
    114.     float fDecPower = 0.1f;  
    115.   
    116.     // 进行首位判断,判断是否是负数  
    117.     if (pstrfloat[0] == L'-')  
    118.     {  
    119.         bNegative = true;  
    120.         pSor = pstrfloat + 1;  
    121.     }  
    122.     else  
    123.     {  
    124.         bNegative = false;  
    125.         pSor = pstrfloat;  
    126.     }  
    127.   
    128.     while (*pSor != L'\0')  
    129.     {  
    130.         chByte = *pSor;  
    131.   
    132.         if (bDec)  
    133.         {  
    134.             // 小数  
    135.             if (chByte >= L'0' && chByte <= L'9')  
    136.             {  
    137.                 fDecimal += (chByte - L'0') * fDecPower;  
    138.                 fDecPower = fDecPower * 0.1;  
    139.             }  
    140.             else  
    141.             {  
    142.                 return (bNegative? -(fInteger +  fDecimal): fInteger + fDecimal);  
    143.             }  
    144.         }  
    145.         else  
    146.         {  
    147.             // 整数  
    148.             if (chByte >= L'0' && chByte <= L'9')  
    149.             {  
    150.                 fInteger = fInteger * 10.0 + chByte - L'0';  
    151.             }  
    152.             else if (chByte == L'.')  
    153.             {  
    154.                 bDec = true;  
    155.             }  
    156.             else  
    157.             {  
    158.                 return (bNegative? -fInteger : fInteger);  
    159.             }  
    160.         }  
    161.   
    162.         pSor++;  
    163.     }  
    164.   
    165.     return (bNegative? -(fInteger +  fDecimal): fInteger + fDecimal);  
    166. }  
    167. // -------------------------------------------------------------------------  
    168. // $Log: $  

            测试用例:

    1. // StringToFloatShell.cpp : Defines the entry point for the console application.  
    2. //  
    3.   
    4. #include "stdafx.h"  
    5. #include "StringToFloat.h"  
    6.   
    7.   
    8. int _tmain(int argc, _TCHAR* argv[])  
    9. {     
    10.     float aaaa = 0;  
    11.     aaaa = StrToFloat(L"12.34");  
    12.     aaaa = StrToFloat(L"a23");  
    13.     aaaa = StrToFloat(L"1234");  
    14.     aaaa = StrToFloat(L"12.34");  
    15.     aaaa = StrToFloat(L"12.34.56");  
    16.     aaaa = StrToFloat(L".34");  
    17.     aaaa = StrToFloat(L"34a");  
    18.     aaaa = StrToFloat(L"34a.456");  
    19.     aaaa = StrToFloat(L"-34");  
    20.     aaaa = StrToFloat(L"-56.34");  
    21.     aaaa = StrToFloat(L"-3.45.67");  
    22.     aaaa = StrToFloat(L"-.45.6a");  
    23.     aaaa = StrToFloat(L"-.");  
    24.     aaaa = StrToFloat(L"-0");  
    25.     return 0;  
    26. }  

            大家可以再找找BUG。

            原文地址:http://blog.csdn.net/magictong/article/details/6900410

    展开全文
  • Python字符串转换成浮点数函数分享利用map和reduce编写一个str2float函数,把字符串'123.456'转换成浮点数123.456from functools import reducedef str2float(s):return reduce(lambda x,y:x+int2dec(y),map(str2int...
  • 为对象引用赋予的名称称为标识符,有效的标识符包括引导字符和后续字符,只要是Unicode编码的字母,都可以充当引导字符,后续字符可以是数字,下划线,或任意非空字符; 1.标识符大小写敏感; 2.标识符不能使用...
  • 所以在转换前,需要先进行判断字符串的类型。 判断字符串是否为数字(整形) 这个直接调用python的库就可以了哈,假设str为字符串 str.isdigit() 判断所有字符都是数字(整形) 返回值 True:该字符串都为...
  • Python 回忆录2020/8/20赋值数据类型运算整数 intint()实现类型转化浮点数 float时间小练习布尔值,比较运算符,逻辑运算符,同一运算符is 和 == 的区别字符串字符串编码引号创建字符串转义字符字符串拼接str()...
  • Float Convert delphi浮点数转换程序,将浮点数类型转换成字符串,输入浮点数后,可以指定是否对十进制指数部分、一定使用指数等,还可选择二进制(Binary)、八进制(Octal)、十六进制(Hexdecimal)等。运行时请把...
  • 分数转浮点数 如: 1 / 5 =0.2 1 / 3 = 0.(3) 11 / 90 = 0.1(2) numerator: 分子 denominator: 分母 std::string fraction2string(int numerator, int denominator) { if (denominator == 0) { return ...
  • str为字符串s为字符串 str.isalnum() 所有字符都是数字或者字母 str.isalpha() 所有字符都是...检查字符串是数字/浮点数方法 float部分 &gt;&gt; float('Nan') nan &gt;&gt; float('Nan') n...
  • 本文给大家带来三种方法基于Python判断字符串是否为字母或者数字(浮点数),非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下 str为字符串s为字符串 str.isalnum() 所有字符都是数字或者字母 str.isalpha()...
  • str.indexOf('指定字符串',检索位子 为Num 可不传) 返回值为找到的内容出现的位置 search() 方法用于检索字符串中指定的子字符串,或检索与正则表达式相匹配的子字符串。 str.search(regexp) 返回第一个与 regexp ...
  • 浮点数转化为字符串程序分析

    千次阅读 2006-10-26 10:57:00
    程序的思路是:首先判断一个浮点数是正的还是负的,如果是负数,则需要先把字符串数组的第0个元素设置为0。然后,(如果是正数也从这里开始),把浮点数乘以1000或者100000之类的(根据所需要的精度)并强制转化成...
  • 判断输入的字符串是否为数字

    千次阅读 2019-09-27 18:35:43
    创建一个函数,使其接收一个字符串判断字符串是否为数字。 代码实现 C #include <ctype.h> #include <stdlib.h> int isNumeric (const char * s) { if (s == NULL || *s == '\0' || isspace(*s)) ...
  • 有时我们需要将输入的一串字符改成它所含的意义的整数形式,浮点数形式。通常这种情况下我们会自己写一个函数然后遍历加判断再输出,太过麻烦。可是其实本来是有类似的函数存在的。 std::stoi; std::stol; ...
  • //判断是否为整形: - (BOOL)isPureInt:(NSString*)string{  NSScanner* scan = [NSScanner scannerWithString:string];  int val;  return[scan scanInt:&val] && [scan isAtEnd]; } ...
  • 浮点数转换到16进制字符串

    千次阅读 2008-03-31 17:41:00
    先觉得,通过Text建立会比较慢,因为要用到geometryfromtext,与把数据转换成文本再让数据库进行转换,不如自己进行转换成 WKB形式的第一段的难点就是将double类型转换成十六进制字符串 ,就是将64bit转换成16进制...
  • 这段时间,正值大四上学期,同学们都各种忙着找工作,前一段时间,寝室的一个搞Java的同学参加完笔试,回到寝室后,拿着笔试卷子问我一道编程题:实现浮点数转换成人民币读法字符串的小程序。也忘了当时在忙什么把这...
  • //编写一个函数,将以字符串形式给出的浮点数的十六进制形式转换成十进制形式 //请严格按照格式输入:例如:0x*.* //程序有个bug,就是必须输入浮点数!必须有小数点 #include #include #include #include #...
  • C# 判断字符串是否可以转化为数字

    千次阅读 2014-01-24 10:32:30
    /// /// 判断字符串是否可以转化为数字 /// /// 要检查的字符串 /// true:可以转换为数字;false:不是数字 public static bool IsNumberic(string str) { double vsNum; b
  • python字符串字符串处理函数及字符串相关操作

    万次阅读 多人点赞 2014-04-12 23:23:25
    http://blog.csdn.net/pipisorry/article/details/42085723字符串介绍python字符串表示Python除处理数字外还可以处理字符串字符串用单撇号或双撇号包裹:&gt;&gt;&gt; 'spam eggs' 'spam eggs' &...
  • function checkRates(str){  var re = /^(([1-9][0-9]*\.[0-9][0-9]*)|([0]\.[0-9... //判断字符串如果是整数不能以0开头后面加正整数,如果是浮点数整数部分不能为两个0:如00.00,如果是整数,  var Sure;  if (!
  • 原题:利用 map 和 reduce 编写一个 str2float 函数,把字符串'123.456'转换成浮点数 123.456这是我在学习python过程中写到的一个题,答案非原创from functools import reduce def str2float(s): def fn(x,y): ...
  • function checkRates(str){  var re = /^(([1-9][0-9]*\.[0-9][0-9]*)|([0]\.... //判断字符串如果是整数不能以0开头后面加正整数,如果是浮点数整数部分不能为两个0:如00.00,如果是整数,  var Sure;  if (!
  • python字符串操作 raw字符串

    千次阅读 2019-08-19 16:43:20
    字符串 str(string) 作用:用来记录文字信息,整数编码(UNICODE) 表示方法: 在非注释当中凡是用引号括起来的部分都是字符串 ‘ ’ 单引号 “ ” 双引号 ‘‘‘ ’’’ 三单引号(可以隐式折行) “““ ””...
  • Description输入一字符判断它是不是浮点数形式(定点形式或科学记数形式),是则输出YES;否则输出NO。如输入" 123"、或"123.57"、"123e12",”+1.2E+3”, 则输出YES。如输入" 123A"、或"123.57.89",则输出NO。...
  • mysql解析json字符串字符串查找,子串截取和字段类型转换相关总结 很多时候,我们需要在sql里面直接解析json字符串。这里针对mysql5.7版本的分水岭进行区分。 1.对于mysql5.7以上版本  使用mysql的内置函数...
  • 字符串 https://ww2.mathworks.cn/help/matlab/characters-and-strings.html 创建字符向量 通过将字符序列括在单引号中来创建一个字符向量。 chr = 'Hello, world' chr = 'Hello, world' 字符向量为 char 类型的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,502
精华内容 19,800
关键字:

判断浮点数形式字符串