精华内容
下载资源
问答
  • 浮点型转字符串

    2020-12-15 14:30:15
    static std::string float2string(float fScore, int precisionNum) { std::string strScore; std::stringstream ss; ss << std::setprecision(precisionNum) << fScore; strScore = ss.str();...}
    static std::string float2string(float fScore, int precisionNum)
    {
        std::string strScore;
        std::stringstream ss;
        ss << std::setprecision(precisionNum) << fScore;
        strScore = ss.str();
        return strScore;
    }
    

     

    展开全文
  • 这份文档介绍了在C的编程中,如何把浮点型的数据抓换成字符串形式进行输出。
  • 浮点型转字符串是最常见的一个功能了,对于弱类型语言来说更是几乎感觉不到。但现在问个问题?用C语言写一个浮点数转字符串的函数,有多难呢? 一开始写这个函数的时候是大二的时候,那时候在学C51单片机,用到1602...

    浮点型转字符串是最常见的一个功能了,对于弱类型语言来说更是几乎感觉不到。但现在问个问题?用C语言写一个浮点数转字符串的函数,有多难呢?

    一开始写这个函数的时候是大二的时候,那时候在学C51单片机,用到1602显示屏,就是下图这货,通常遇到的情况就是要想要在屏幕上显示整数或者浮点数,1602封装的字库里面接口规范里接收的是字符串,所以在写程序时必须先把整数和浮点数转换成字符串。当时我就找到好像说 itoa , ftoa 这样的方法,但是那两个方法需要使用 stdlib.h 库,而Keil C51 IDE里面没有提供这个库,网上找了很久也没有找到答案,于是就自己着手写了。后来才知道,在stdio.h里面有一个sprintf函数可以做这种转换的事情,这已经是一年多后毕业求职时在某家公司面试的时候被告知的。

    下面开始介绍浮点型转字符串的基本思路:

    1、判断是否为负数,若是负数则作标记,在最后字符串合成时加上负号“-”,并取其绝对值;

      例:-999.98,则设定负数标记位置1,并取其绝对值999.98

    2、把浮点串拆分为整数部分和小数部分;

      例:999.98拆分成 999 和 0.98

    3、先处理小数部分还是整数部分?答案是小数部分,因为小数部分可能会四舍五入进位,对整数部分造成影响;

    4.1、小数部分,假设这里要保留两位小数,取最后一位数字是到哪位呢?实践证明答案是三位,如果取两位,很可能会得到不可思议的结果;

      例:0.98乘以100后得到的结果可能不是98而是97,而乘以1000后得到的结果可能不是980而是979

      因为计算机记录小数是不精确的,在运算时可能会有细小误差,所以我们要取多一位进行四舍五入

    4.2、因为可能进位的原因,从最低位开始逐步获取数字,并使用进位标置判断更新数字;

      例:0.98乘以1000=>979,取最后一位数得到 '9',9>=5,所以标记进位;下一个得到 '7',加上进位标记变成 '8',复位进位标记;再下一个得到 '9';整理起来小数部分得到的字符串就是 '9'、'8';

      Tips:整型数字要加上0x30(十进制48)转为其对应的ASCII字符,如:9+0x30='9'

    4.3、为了说明前面有所提及的整数进位情况,从这里假设为保留一位小数再来演示一次;

      例:0.98乘以100=>97,取最后一位得到 '7',7>=5,所以标记进位;下一个得到 '9',加上进位标记变成 10,所以取得数字 '0', 标记位继续有效,因为这个是小数的最大一位了,所以这个进位要进到整数中去,这里要做好标记

    5.1、整数部分,假设最高支持5位,从高位到低位分别取出数字;

      例:999取得 '0'、'0'、'9'、'9'、'9'

    5.2、整数部分,处理小数进位到整数来的标记,从最低到最高位逐级进位

      例:这里的 9 一直进位,直到最高一位从 0 变成了 1,'0'、'0'、'9'、'9'、'9'变成了 '0'、'1'、'0'、'0'、'0'

    5.3、整数部分,从高位到低位判断非0第一次出现的位置,定为整数部分的字符串,前面的0忽略;

      例:01000的真正字符串是'1'、'0'、'0'、'0',前的一个'0'忽略

    6、拼装小数部分、整数部分、小数点和可能的负号;

      例:保留一位小数得到了 "-1000.0"

     

    陷阱总结:

    1、小数部分一定要取到保留的下一位,即使看起来保留的下一位就是0,否则可能会 1.8 变成 "1.7" 而实际是 1.79...

    2、小数部分不能直接向整数部分一样乘以一个数然后去掉前面的0,否则会使像 1.02 变成 "1.2",把小数中的前面的0吃掉了;

    3、记得取出的数字要转成字符,更要注意大小比较时,数字要与数字相比较,字符要与字符相比较,不可混用,两者大小相差48;

    4、留意每一步的进位,小数到整数部分的进位最容易被忽视;

     

    如果没做,真的没想到一个如此基础的函数其间要处理问题是如此之多,很感谢那些算法大牛们为我们铺好一条条康庄大道,让我们在编程的世界里更加轻松地驰骋。下面是我一年前大学三年级时用C语言写的实现代码,跟上面说的思路在细节上稍有顺序不同,可能看起来非常冗余,可能还有一些尚未发现的BUG,可能大家会有更高明的实现算法。还请多多交流。

      1 //浮点型转字符串
      2 void float2Str(double fda,char *pString,uint8 dNum){
      3     uint8 i;
      4     bit negative=0;    //负数标志位
      5     bit X999        = 0;        //小数部分四舍五入进位标志
      6     bit XtoZ        = 0;        //小数到整数的进位标志
      7     uint8 intLen=5;
      8     uint8 cdat[6]={0};        //分部分时的字符串
      9     uint8 whole[18]={0};    //整个数的字符串,其中留多一位为0x00    
     10 
     11     int ida;                //整数部分
     12     double dec;                //小数部分
     13     
     14     if (fda < 0){                //若为负数取绝对值
     15         fda = -fda;
     16         negative = 1;    
     17     }
     18     ida = (int) (fda) ;
     19     dec = fda - ida;
     20     
     21 ///小数部分转换//    
     22     if (dNum >= 6)            //小数最多显示5位
     23         dNum = 5;
     24     switch (dNum +1){
     25         case 6:{
     26             cdat[5] = (char)  (((long) (dec *1000000l))%10);    //0.0000001位    
     27             whole[15+ 6-dNum] = cdat[5] + 0x30;    
     28             //四舍五入算法
     29             if (X999 == 1){
     30                 if (whole[15+ 6-dNum] < '9'){        //小于9就加1
     31                     whole[15+ 6-dNum] += 1;    
     32                     X999 = 0;
     33                 }else{            //否则继续进位,本位置0
     34                     whole[15+ 6-dNum] = '0';
     35                 }                    
     36             }
     37             
     38             if ( dNum==5){                
     39                 if (whole[15+ 6-dNum] >= '5')
     40                     X999 = 1;
     41                 whole[15+ 6-dNum] = 0x00;
     42             }
     43             //
     44             
     45         }
     46         case 5:{
     47             cdat[4] = (char)  (((long) (dec *100000l))%10);        //0.000001位    
     48             whole[15+ 5-dNum] = cdat[4] + 0x30;    
     49             //四舍五入算法
     50             if (X999 == 1){
     51                 if (whole[15+ 5-dNum] < '9'){        //小于9就加1
     52                     whole[15+ 5-dNum] += 1;    
     53                     X999 = 0;
     54                 }else{            //否则继续进位,本位置0
     55                     whole[15+ 5-dNum]  = '0';
     56                 }                    
     57             }
     58             
     59             if ( dNum==4){                
     60                 if (whole[15+ 5-dNum] >= '5')
     61                     X999 = 1;
     62                 whole[15+ 5-dNum] = 0x00;
     63             }
     64             //
     65     
     66         }
     67         case 4:{
     68             cdat[3] = (char)  (((long) (dec *10000l))%10);        //0.00001位
     69             whole[15+ 4-dNum] = cdat[3] + 0x30;        
     70             //四舍五入算法
     71             if (X999 == 1){
     72                 if (whole[15+ 4-dNum] < 0x39){        //小于9就加1
     73                     whole[15+ 4-dNum] += 1;    
     74                     X999 = 0;
     75                 }else{            //否则继续进位,本位置0
     76                     whole[15+ 4-dNum]  = '0';
     77                 }                    
     78             }
     79             
     80             if ( dNum==3){                
     81                 if (whole[15+ 4-dNum] >= '5')
     82                     X999 = 1;
     83                 whole[15+ 4-dNum] = 0x00;
     84             }
     85             //
     86 
     87         }
     88         case 3:    {
     89             cdat[2] = (char)  (((long) (dec *1000l))%10);            //0.001位
     90             whole[15+ 3-dNum] = cdat[2] + 0x30;        
     91             //四舍五入算法
     92             if (X999 == 1){
     93                 if (whole[15+ 3-dNum] < 0x39){        //小于9就加1
     94                     whole[15+ 3-dNum] += 1;    
     95                     X999 = 0;
     96                 }else{            //否则继续进位,本位置0
     97                     whole[15+ 3-dNum]  = '0';
     98                 }
     99             }
    100             if ( dNum==2){                
    101                 if (whole[15+ 3-dNum] >= '5')
    102                     X999 = 1;
    103                 whole[15+ 3-dNum] = 0x00;
    104             }
    105             //
    106             
    107         }
    108         case 2:{
    109             cdat[1] = (char)  (((long) (dec *100l))%10);            //0.01位
    110             whole[15+ 2-dNum] = cdat[1] + 0x30;    
    111             //四舍五入算法
    112             if (X999 == 1)    {
    113                 if (whole[15+ 2-dNum] < 0x39){        //小于9就加1
    114                     whole[15+ 2-dNum] += 1;
    115                     X999 = 0;
    116                 }else{            //否则继续进位,本位置0
    117                     whole[15+ 2-dNum]  = '0';
    118                 }
    119             }
    120             if ( dNum==1){                
    121                 if (whole[15+ 2-dNum] >= '5')
    122                     X999 = 1;
    123                 whole[15+ 2-dNum] = 0x00;
    124             }
    125             //
    126             
    127         }    
    128         case 1:{
    129             cdat[0] = (char)  (((long) (dec *10l))%10);                //0.1位
    130             whole[15+ 1-dNum] = cdat[0] + 0x30;    
    131             //四舍五入算法
    132             if (X999 == 1){
    133                 if (whole[15+ 1-dNum] < 0x39)
    134                     whole[15+ 1-dNum] += 1;    
    135                 else{
    136                     XtoZ = 1;
    137                     whole[15+ 1-dNum] = '0';    
    138                 }
    139                 X999 = 0;
    140             }
    141             
    142             if ( dNum==0){                
    143                 if (whole[15+ 1-dNum] >= '5')
    144                     XtoZ = 1;
    145                 whole[15+ 1-dNum] = 0x00;
    146             }
    147             /
    148             
    149         }            
    150     }
    151     
    152 /添加小数点////    
    153     whole[15 - dNum] = '.' ;
    154     
    155 ///整数部分转换//    
    156     cdat [0] = (char)(ida / 10000 ) ;
    157     cdat [1] = (char)((ida % 10000) /1000);
    158     cdat [2] = (char)((ida % 1000) /100);
    159     cdat [3] = (char)((ida % 100) /10);
    160     cdat [4] = (char)((ida % 10) /1);
    161     for (i=0;i<5;i++){                        //转换成ASCII码
    162         cdat[i] = cdat[i] + 48;
    163     }
    164     
    165     //四舍五入算法,整数部分(未完)
    166     if (XtoZ == 1){
    167         if (cdat[4] < '9'){                //个位小于9
    168             cdat[4] += 1;            
    169         }else{
    170             cdat[4] = '0';
    171             if (cdat[3] < '9'){            //十位小于9
    172                 cdat[3] += 1;
    173             }else{
    174                 cdat[3] = '0';
    175                 if (cdat[2] < '9'){        //百位小于9
    176                     cdat[2] += 1;
    177                 }else{
    178                     cdat[2] = '0';
    179                     if (cdat[1] < '9'){    //千位小于9
    180                         cdat[1] += 1;
    181                     }else{
    182                         cdat[1] = '0';
    183                         cdat[0] += 1;        //万位加1
    184                     }
    185                 }                
    186             }
    187         }
    188         XtoZ = 0;
    189     }
    190     
    191     ////    
    192     if (cdat[0] == '0'){
    193         intLen = 4;
    194         if (cdat[1] == '0'){
    195             intLen = 3;
    196             if (cdat[2] == '0'){
    197                 intLen = 2;
    198                 if (cdat[3] == '0')
    199                     intLen = 1;            
    200             }
    201         }
    202     }
    203     
    204     for (i=0;i<5;i++){
    205         whole[10 + i - dNum] = cdat[i];        
    206     }        
    207 ///拼合符点数/    
    208     if (negative == 1){
    209         whole [ 14 - intLen - dNum] = '-';
    210         for ( i=(14 - intLen - dNum) ;i<19; i++){
    211             *pString = whole[i];        
    212             pString ++;
    213         }
    214     }else{
    215         for ( i=(15 - intLen - dNum) ;i<19; i++){
    216             *pString = whole[i];    
    217             pString ++;
    218         }        
    219     }    
    220     
    221 }

     

    转载于:https://www.cnblogs.com/batsing/p/4876280.html

    展开全文
  • 在MFC程序中,CString既可以处理Unicode标准的字符串,也可以处理ANSI标准的字符串。 Format用于转换的格式字符 %c单个字符 %d十进制整数(int) %ld十进制整数(long) %f

         在MFC程序中,CString既可以处理Unicode标准的字符串,也可以处理ANSI标准的字符串。

    FormatVC各种字符串转换用于转换的格式字符

           %c                 单个字符
           %d                 十进制整数(int)
           %ld                十进制整数(long)
           %f                 十进制浮点数(float)
           %lf                十进制浮点数(double)
           %o                 八进制数
           %s                 字符串
           %u                 无符号十进制数
           %x                 十六进制数

    使用方法

    1、int转换为CString   字符串转int
    int num = 9;
    str.Format(_T(%4d), num);
    
     
    2、十进制转八进制
    int num = 9;
    str.Format(_T(%o), num);
    
     
    展开全文
  • 前言 整型、浮点型与字符串的相互转换可以用自带的函数来实现...一、整型转字符串型 1.int转为字符串 itoa(int _Value, char *_Buffer, int _Radix);  需改为_itos_s(int _Value, char *_Buffer, size_t _Buf...

    前言

    整型、浮点型与字符串的相互转换可以用自带的函数来实现,本人使用的是vs2015,所以下面有些函数需要改变一下,请看下面的总结。

    正文

    一、整型转字符串型

    1. int转为字符串

    itoa(int _Value, char *_Buffer, int _Radix);  

    需改为_itos_s(int _Value, char *_Buffer, size_t _BufferCount, int _Radix);

    _Radix:表示进制,若十进制则Radix为10

    _BufferCount:存储的大小,不可以比Buffer的长度大

    #include <iostream>
    
    using namespace std;
    
    void main()
    {
        int num = 10;
        char str[3];                        // str的长度最少为3,因为10虽然两位,但还有一个结束符
        _itoa_s(num, str, sizeof(str), 10);    // int转为字符串
        cout << str << endl;                // 输出结果为10
    }

    2. long int转为字符串

    ltoa(long _Value, char *_Buffer, int _Radix);  

    改为_ltoa_s(long _Value, char *_Buffer, size_t _BufferCount, int _Radix);

    3. 无符号长整型转为字符串

    ultoa(unsigned long _Value, char *_Buffer, int _Radix);  

    改为_ultoa_s(unsigned long _Value, char *_Buffer, size_t _BufferCount, int _Radix);

    4. int型转为宽字符串型

    _itow(int _Value, wchar_t *_Buffer, int _Radix); 

    改为_itow_s(int _Value, wchar_t *_Buffer, size_t _BufferCount, int _Radix);

    二、浮点型转字符串型

    1. double型转为字符串

    gcvt(double _Value, int _DigitCount, char* _DstBuf);  

    改为_gcvt_s(char* _Buffer, size_t _BufferCount, double _Value, int _DigitCount);

    说明:显示正负号、小数点

    _Digitcount:显示的位数,如1.25,显示两位是1.3(四舍五入),显示三位是1.25

    #include <iostream>
    
    using namespace std;
    
    void main()
    {
        double num = -1.235;                
        char str[7];                        // 在字符串中,正负号、小数点、结束符各占一位
        _gcvt_s(str, sizeof(str), num, 3);    // double转为字符串,显示三位,1.235四舍五入为1.24
        cout << str << endl;                // 输出结果为-1.24
    }

    2. double转换为字符串

    ecvt(double _Value, int _DigitCount, int *_PtDec, int *_PtSign);  

    改为_ecvt_s(char *_Buffer, size_t _BufferCount, double _Value, int _DigitCount, int *_PtDec, int *_PtSign);

    说明:不显示小数点和正负号

    _PtDec:表示小数点位置,若_PtDec为1,说明小数点左边有一个数

    _PtSign:表示正负号,0为正数,1为负数

    #include <iostream>
    
    using namespace std;
    
    void main()
    {
        double num = -1.235;
        int Dec, Sign;                                    // Dec:小数点位置,Sign:正负号
        char str[5];                                    // ?至少5位
        _ecvt_s(str, sizeof(str), num, 3, &Dec, &Sign);    // double转str,剔除正负号和小数点,显示三位,1235四舍五入为124
        cout << str << endl;                            // 输出结果为124
        cout << Dec << endl;                            // 输出结果为1,小数点左面有一个数
        cout << Sign << endl;                            // 输出结果为1,是负数
    }

    3. double转换为字符串

    fcvt(double _Value, int _FractionalDigitCount, int *_PtDec, int *_PtSign);

    改为_fcvt(char *_Buffer, size_t _BufferCount, double _Value, int _FractionalDigitCount, int *_PtDec, int *_PtSign);

    说明:转换结果中不包含小数点和正负号

     _FractionalDigitCount:取小数位数,若_FractionalDigitCount为1,则取一位小数,要四舍五入

    #include <iostream>
    
    using namespace std;
    
    void main()
    {
        double num = -1.235;
        int Dec, Sign;                                    // Dec:小数点位置,Sign:正负号
        char str[5];                                    // ?至少5位
        _fcvt_s(str, sizeof(str), num, 2, &Dec, &Sign); // double转str,剔除正负号和小数点,取两位小数,1235四舍五入为124
        cout << str << endl;                            // 输出结果为124
        cout << Dec << endl;                            // 输出结果为1,小数点左面有一个数
        cout << Sign << endl;                            // 输出结果为1,是负数
    }

    三、字符串型转整型

    1.将字符串转为int型

     int atoi(const char *_String);

    2. 将字符串转为long型

    long atol(const char *_String);
    3. 将字符串转为long型,并报告不能被转换的所有剩余部分

    long strtol(const char *_String, char **_EndPtr, int _Radix);

    _Radix:表示进制,范围为2~36和0

    _EndPtr:指向字符串中不合法的部分

    说明:若_Radix为2,则‘0’、‘1’合法,若_Radix为10,则‘0’、‘1’……‘9’合法,若_Radix为16,则‘0’,‘1’……‘f’合法

    #include <iostream>
    
    using namespace std;
    
    void main()
    {
        long num_2, num_8, num_10, num_16;
        char str[20] = "1079aeg";
        char *str1;
        num_2 = strtol(str, &str1, 2);        // 二进制,10合法
        cout << num_2 << endl;                // 输出2,二进制10在十进制中为2
        cout << str1 << endl;                // 输出不合法的79aeg
        num_8 = strtol(str, &str1, 8);        // 8进制,107合法
        cout << num_8 << endl;                // 输出71,八进制107在十进制中为71
        cout << str1 << endl;                // 输出不合法的9aeg
        num_10 = strtol(str, &str1, 10);    // 10进制,1079合法
        cout << num_10 << endl;                // 输出1079
        cout << str1 << endl;                // 输出不合法的aef
        num_16 = strtol(str, &str1, 16);    // 十六进制,1079ae合法
        cout << num_16 << endl;                // 输出1079726,十六进制1079ae在十进制中为1079726
        cout << str1 << endl;                // 输出不合法的g
    }

    ------

    如若想详细了解该函数,请看strtol()详解

    4. 将字符串转为无符号长整型值,并报告不能被转换的所有剩余部分

    unsigned long strtoul(const char *_String, char **_EndPtr, int _Radix);

    四、字符串型转浮点型

    1. 将字符串转换为双精度浮点型值

    double atof(const char *_String);

    2. 将字符串转换为双精度浮点型值,并报告不能被转换的所有剩余数字

    double strtod(const char *_String, char **_EndPtr);

    参考资料

    C语言itoa()函数和atoi()函数详解(整数转字符C实现)
    有关int,float,double型与字符串char*类型的相互转换
    Strtol()详解

     

    转载于:https://www.cnblogs.com/onycea/p/5400681.html

    展开全文
  • 浮点型/整型转字符串

    2020-11-19 12:56:24
    浮点型/整形转字符串转字符串 前言  有时我们在编写ESP8266程序的时候,库函数提供的sprintf()函数不能将浮点型数据转为字符串。或者在编写内存较小的单片机时,使用sprintf()等库函数会占用较大的代码空间,这时...
  • 这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录 想要对字符串类型进行转换问题: 字符串必须为有意义的字符串 (无意义为包含汉字, 是其他的已知类型)
  • Python-字符串转浮点型,列表转字符串

    千次阅读 2018-06-29 23:02:17
    取列表中的元素 并 转字符串 取列表第一个元素 取列表全部元素 应用场景 爬虫过程中,采集的数据常以str或float存入数据库; 遇到含小数点的文本,需要转换成浮点型 xpath()或re.findall()提取信息返回列表,列表...
  • 在程序中,可能会遇到需要将浮点型的数据转换成字符串:#includevoidfloat2char(float,char*,int);intmain(){charbuffer[10];float2char(123.4567,buffer,10);printf("%f转换成字符串%s\n",123.4567,buffer);float2...
  • 参考文章链接:1.http://c.biancheng.net/cpp/html/1573.html2.http://c.biancheng.net/cpp/html/1574.html1....字符串整数转换为字符串:---------------------------------------------------------- 函数名 ...
  • 今天的学习内容有:整型(进制转换)、浮点型字符串类型和列表类型。 整型(int) 整型定义方式 age = 18 # age = int(18) ps:int只能纯数字的字符串,小数点都不行 进制转换 其他进制10进制 二...
  • C语言浮点型转字符串

    千次阅读 2019-05-20 09:37:47
    代码如下, #include <stdio.h> #include <stdlib.h> int main() ... //double处理方式相同 char b[5]; sprintf(b,"%2.1f",a); //精度为0.1 printf("%s\n",b); return 0; }...
  • #include &lt;stdio.h&gt; bool ftos(float num,char *s,int n) {  int temp; float t=num; int pn=0; bool flag_s=true; bool flag_z=false; for(int i=n;...printf(...
  • 数值类型的转换5.1 整型转换为浮点型5.2 浮点型转换为整型5.3 字符串型转换看情况5.3.1 字母型字符串5.3.2 数字型字符串6.删除变量 1.整型 在 Python 中,可对整数执行加( + )减( - )乘( * )除( / )运算。 >>&...
  • FR:徐海涛(Hunk Xu) QQ技术群:386476712
  • --bool型和浮点型字符串 1. bool型细节 1.要指定一个布尔值,使用关键字 TRUE 或FALSE。两个都不区分大小写。 2. bool类型转换 1)当转换为 boolean 时,以下值被认为是 FALSE: 3. 浮点型细节 4. 字符串...
  • 整型的定义和输入输出,大小, 字符, 实型, 字符串常量,字符的输入与输出,格式化输入与输出, 类型转换
  • >>> float(1)/(10+10-1) 0.05263157894736842 >>> a = float(1)/(10+10-1) ... File "C:\Program Files (x86)\JetBrains\PyCharm Community Edition 4.0.5\helpers\pydev\pydevd_exec.py", line 3,...
  • java中将整型和浮点型转字符串

    千次阅读 2017-09-06 15:44:37
    String s; int a; double b; s=Integer.toString(a); s=Double.toString(b);
  • 字符串转浮点型数值

    2021-04-29 09:30:25
    字符串转浮点型数值函数–C语言 #include<stdio.h> #include<string.h> /*-----字符串转化为数字-----*/ /*-----只有当是数值型的字符串时,才可以完成字符串的转换。目前仅仅是完成了整数部分的转换,*...
  • 一:整型int #======================================基本使用====================================== ...#数据类型转换:可以将纯数字的字符串转换成整型 n=int('12121212') print(n,type(n)) #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,516
精华内容 1,006
关键字:

浮点型转字符串