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);
    }

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代表的是参数列表里面序号

        之前面试的时候，常给面试者出的一个面试题目是，给定一个字符串，输出该字符串表示的浮点数的值，要求如下：
 
        写一个转换函数，该函数的输入是一个表示浮点数的字符串，把该字符串转换成浮点数并输出。条件：请考虑各种情况，并且代码中的循环尽量少，不能调用API或者crt库中的函数。例如：输入字符串"345.7"，则输出浮点数345.7。接口可以为：float StrToFloatA(TCHAR* pstrfloat);
 
        没想到完全做对这个题目的人居然不多（上机笔试，函数写好之后丢到测试机里面跑一下看是否完全正确），因此自己在空闲时间实现了一下，确实还是有一点难度的。代码如下：
 
 
 
 
 
  
 
   [cpp] view plaincopy 
   
 
   
 
  
 
 
 
 
 /* ------------------------------------------------------------------------- 
 //  文件名     ：   StringToFloat.h 
 //  创建者     ：   magictong 
 //  创建时间    ：   2011-9-6 14:14:25 
 //  功能描述    ：    
 // 
 //  $Id: $ 
 // -----------------------------------------------------------------------*/  
 #ifndef __STRINGTOFLOAT_H__  
 #define __STRINGTOFLOAT_H__  
   
 // -------------------------------------------------------------------------  
 float StrToFloatW(wchar_t* pstrfloat);  
 float StrToFloatA(char* pstrfloat);  
   
 #if defined(UNICODE) || defined(_UNICODE)  
     #define StrToFloat  StrToFloatW  
 #else  
     #define StrToFloat  StrToFloatA  
 #endif // !UNICODE  
 // -------------------------------------------------------------------------  
 // $Log: $  
   
 #endif /* __STRINGTOFLOAT_H__ */  
 
 
 

 
 
 
 
 
  
 
   [cpp] view plaincopy 
   
 
   
 
  
 
 
 
 
 /* ------------------------------------------------------------------------- 
 //  文件名     ：   StringToFloat.cpp 
 //  创建者     ：   magictong 
 //  创建时间    ：   2011-9-6 14:14:02 
 //  功能描述    ：    
 // 
 //  $Id: $ 
 // -----------------------------------------------------------------------*/  
   
 #include "stdafx.h"  
 #include "StringToFloat.h"  
   
 // -------------------------------------------------------------------------  
   
 #pragma warning(disable:4244)  
 // -------------------------------------------------------------------------  
 // 函数       : StrToFloatA  
 // 功能       : 将一个字符串转换为浮点数  
 // 返回值  : float   
 // 参数       : char* pstrfloat  
 // 附注       :   
 // -------------------------------------------------------------------------  
 float StrToFloatA(char* pstrfloat)  
 {  
     // check  
     if (!pstrfloat)  
     {  
         return 0.0;  
     }  
   
     bool bNegative = false;  
     bool bDec = false;  
   
     char* pSor = 0;  
     char chByte = '0';  
     float fInteger = 0.0;  
     float fDecimal = 0.0;  
     float fDecPower = 0.1f;  
   
     // 进行首位判断，判断是否是负数  
     if (pstrfloat[0] == '-')  
     {  
         bNegative = true;  
         pSor = pstrfloat + 1;  
     }  
     else  
     {  
         bNegative = false;  
         pSor = pstrfloat;  
     }  
   
     while (*pSor != '\0')  
     {  
         chByte = *pSor;  
   
         if (bDec)  
         {  
             // 小数  
             if (chByte >= '0' && chByte <= '9')  
             {  
                 fDecimal += (chByte - '0') * fDecPower;  
                 fDecPower = fDecPower * 0.1;  
             }  
             else  
             {  
                 return (bNegative? -(fInteger +  fDecimal): fInteger + fDecimal);  
             }  
         }  
         else  
         {  
             // 整数  
             if (chByte >= '0' && chByte <= '9')  
             {  
                 fInteger = fInteger * 10.0 + chByte - '0';  
             }  
             else if (chByte == '.')  
             {  
                 bDec = true;  
             }  
             else  
             {  
                 return (bNegative? -fInteger : fInteger);  
             }  
         }  
   
         pSor++;  
     }  
   
     return (bNegative? -(fInteger +  fDecimal): fInteger + fDecimal);  
 }  
   
 // -------------------------------------------------------------------------  
 // 函数       : StrToFloatW  
 // 功能       : 将一个字符串转换为浮点数  
 // 返回值  : float   
 // 参数       : char* pstrfloat  
 // 附注       :   
 // -------------------------------------------------------------------------  
 float StrToFloatW(wchar_t* pstrfloat)  
 {  
     // check  
     if (!pstrfloat)  
     {  
         return 0.0;  
     }  
   
     bool bNegative = false;  
     bool bDec = false;  
   
     wchar_t* pSor = 0;  
     wchar_t chByte = L'0';  
     float fInteger = 0.0;  
     float fDecimal = 0.0;  
     float fDecPower = 0.1f;  
   
     // 进行首位判断，判断是否是负数  
     if (pstrfloat[0] == L'-')  
     {  
         bNegative = true;  
         pSor = pstrfloat + 1;  
     }  
     else  
     {  
         bNegative = false;  
         pSor = pstrfloat;  
     }  
   
     while (*pSor != L'\0')  
     {  
         chByte = *pSor;  
   
         if (bDec)  
         {  
             // 小数  
             if (chByte >= L'0' && chByte <= L'9')  
             {  
                 fDecimal += (chByte - L'0') * fDecPower;  
                 fDecPower = fDecPower * 0.1;  
             }  
             else  
             {  
                 return (bNegative? -(fInteger +  fDecimal): fInteger + fDecimal);  
             }  
         }  
         else  
         {  
             // 整数  
             if (chByte >= L'0' && chByte <= L'9')  
             {  
                 fInteger = fInteger * 10.0 + chByte - L'0';  
             }  
             else if (chByte == L'.')  
             {  
                 bDec = true;  
             }  
             else  
             {  
                 return (bNegative? -fInteger : fInteger);  
             }  
         }  
   
         pSor++;  
     }  
   
     return (bNegative? -(fInteger +  fDecimal): fInteger + fDecimal);  
 }  
 // -------------------------------------------------------------------------  
 // $Log: $  
 
 

         测试用例： 
 
 
 
 
  
 
   [cpp] view plaincopy 
   
 
   
 
  
 
 
 
 
 // StringToFloatShell.cpp : Defines the entry point for the console application.  
 //  
   
 #include "stdafx.h"  
 #include "StringToFloat.h"  
   
   
 int _tmain(int argc, _TCHAR* argv[])  
 {     
     float aaaa = 0;  
     aaaa = StrToFloat(L"12.34");  
     aaaa = StrToFloat(L"a23");  
     aaaa = StrToFloat(L"1234");  
     aaaa = StrToFloat(L"12.34");  
     aaaa = StrToFloat(L"12.34.56");  
     aaaa = StrToFloat(L".34");  
     aaaa = StrToFloat(L"34a");  
     aaaa = StrToFloat(L"34a.456");  
     aaaa = StrToFloat(L"-34");  
     aaaa = StrToFloat(L"-56.34");  
     aaaa = StrToFloat(L"-3.45.67");  
     aaaa = StrToFloat(L"-.45.6a");  
     aaaa = StrToFloat(L"-.");  
     aaaa = StrToFloat(L"-0");  
     return 0;  
 }  
 
 
        大家可以再找找BUG。
 
        原文地址：http://blog.csdn.net/magictong/article/details/6900410