字符串与数字相互转化

一.C中的方法

1.  c中字符串转换成数字：一些库函数

头文件：#include<stdlib.h>

atof(),atoi(),atol(),atoll(),strtod(),strtol(),strtoul(),strtof(),strtoll(),strtoull().

（1）strtol（）（将字符串转换成长整型数）

定义函数 long int strtol（const char *nptr，char **endptr，int base）；

base范围从2（2进制）至36（36进制），或0（10进制）。但如果遇到 '0x' / '0X' 前置字符则会使用 16 进制转换，遇到 '0' 前置字符则会使用 8 进制转换。

endstr 为第一个不能转换的字符的指针，若 endptr 不为NULL，则会将遇到的不符合条件而终止的字符指针由 endptr 传回；若 endptr 为 NULL，则表示该参数无效，或不使用该参数。

范例/*将字符串a，b，c分别采用10,2，16进制转换成数字*/

#include<stdlib.h>
main()
{
char a[]=”1000000000”;
char b[]=”1000000000”;
char c[]=”ffff”;
printf(“a=%d\n”,strtol(a,NULL,10));
printf(“b=%d\n”,strtol(b,NULL,2));
printf(“c=%d\n”,strtol(c,NULL,16));
}
执行 a=1000000000
b=512

c=65535

atol（）atoi（）与strtol（nptr，NULL，10）结果相同

（2）atoi（）（将字符串转换成整型数）

定义函数 int atoi(const char *nptr);

atoi（）与strtol（nptr，NULL，10）结果相同

范例 /* 将字符串a 与字符串b转换成数字后相加*/
#include<stdlib.h>
mian()
{
char a[]=”-100”;
char b[]=”456”;
int c;
c=atoi(a)+atoi(b);
printf(c=%d\n”,c);
}

执行 c=356

（3）atol（）（将字符串转换成长整型数）

定义函数 long atol(const char *nptr);

atol（）与strtol（nptr，NULL，10）结果相同

范例 /*将字符串a与字符串b转换成数字后相加*/
#include<stdlib.h>
main()
{
char a[]=”1000000000”;
char b[]=” 234567890”;
long c;
c=atol(a)+atol(b);
printf(“c=%d\n”,c);
}

执行 c=1234567890

（4）atof（）（将字符串转换成浮点型数）

定义函数 double atof（const char *nptr）;

atof（）与strtod（nptr,NULL,）结果相同

范例 /* 将字符串a 与字符串b转换成数字后相加*/

#include<stdlib.h>
main()
{
char *a=”-100.23”;
char *b=”200e-2”;
float c;
c=atof(a)+atof(b);
printf(“c=%.2f\n”,c);
}

执行 c=-98.23

（5）strtod（）（将字符串转换成浮点数）

定义函数double strtod（const char *nptr,char **endptr）;

atof（）与strtod（nptr,NULL）结果相同

（6）atoll（）和strtoll（）（将字符串转换成long long型）

long long atoll（const char *nptr）;

long long strtoll（const char *nptr,char ** endptr,int base）;

2.c中数字转换成字符串：一些库函数

c语言提供了几个标准库函数，可以将任意类型（整型，长整型，浮点型等）的数字转换成字符串。

（1）itoa（）将整型值转换为字符串

ltoa（）将长整型值转换为字符串

ultoa（）将无符号长整型值转换为字符串

以下是itoa（）一个例子：

# include <stdio. h>
# include <stdlib. h>
void main (void);
void main (void)
{
    int num = 100;
    char str[25];
    itoa(num, str, 10);
    printf("The number 'num' is %d and the string 'str' is %s. \n" ,
                       num, str);

}

itoa（）函数有3个参数，第一个参数是要转换的数字，第二个参数是要写入转换结果的目标字符串，第三个参数是转换数字时所用的基数。在上例中，转换基数是10.

请注意：上述函数与ANSI标准是不兼容的。能将整数转换为字符串且与ANSI标准兼容的方法是sprintf（）函数.

（2）将浮点型数字转换为字符串时，需要另一组函数。

头文件：#include<stdlib.h>

a.     ecvt（）将双精度浮点型值转换为字符串，转换结果中不包含十进制小数点和正负号

char *ecvt(double num,int ndigit,int *decpt,int *sign);

num:要转换的浮点数

ndigit：转换后的有效数字的位数，如果个数少于ndigit，用0填充。

decpt：存储小数点的位数，从字符串的开头计算。

sign：存储num的符号，0为正，1为负。

#include   <stdlib.h>
#include   <stdio.h>
#include   <conio.h>
int   main()
{
        char   *string;
        double   value;
        int   dec,sign;
        int   ndig=5;
        //clrscr();
        value=9.876;
        string=ecvt(value,ndig,&dec,&sign);
        printf( "string=%s   dec=%d   sign=%d ",string,dec,sign);
        value=-123.45;
        ndig=   15;
        string=ecvt(value,ndig,&dec,&sign);
        printf( "string=%s   dec=%d   sign=%d ",string,dec,sign);
        value=0.6789e5;
        ndig=5;
        string=ecvt(value,ndig,&dec,&sign);
        printf( "string=%s   dec=%d   sign=%d ",string,dec,sign);
        return   0;
}

b.   fcvt（）指定转换精度（小数点后的位数），余同ecvt（）

char *fcvt(double num,int ndigit,int *decpt,int *sign);

num:要转换的浮点数

ndigit：小数点后面的位数，不够用0填充

decpt：存储小数点的位置

sign：存储num的符号

#include   <stdlib.h>
#include   <stdio.h>
#include   <conio.h>
int   main()
{
        char   *string;
        double   value;
        int   dec,sign;
        int   ndig=10;
        //clrscr();
        value=9.876;
        string=fcvt(value,ndig,&dec,&sign);
        printf( "string=%s   dec=%d   sign=%d ",string,dec,sign);
        value=-123.45;
        ndig=15;
        string=ecvt(value,ndig,&dec,&sign);
        printf( "string=%s   dec=%d   sign=%d ",string,dec,sign);
        value=0.6789e5;
        ndig=5;
        string=fcvt(value,ndig,&dec,&sign);
        printf( "string=%s   dec=%d   sign=%d ",string,dec,sign);
        return   0;
}

c.   gcvt（）将双精度浮点型值转换为字符串，转换结果中包含十进制小数点和正负号

char *gcvt(double num,int ndigit,char *buf);

num:要转换的浮点数

ndigit：有效数字的位数（如果不够，不用0填充）

buf：存储转换后的字符串

#include <stdlib.h>
#include <stdio.h>
int main()
{
    double a = 12345678.12549;//一供14位数字
    char ptr[128] = {0};
    int i = 0;
    for(i = 1;i < 15;i++)
    {
        gcvt(a,i,ptr);
        printf("a:%f 取%d位转换后：%s\n",a,i,ptr);
    }

    double b = 0.1234567;//一供8位数字
    for(i = 1;i < 9;i++)
    {
        gcvt(b,i,ptr);
        printf("b:%f 取%d位转换后：%s\n",b,i,ptr);
    }
    return 0;
}

（3）sprintf函数将数字转换成字符串

a.      格式化数字字符串

sprintf最常见的应用之一莫过于把整数打印到字符串中，所以，spritnf在大多数场合可以替代itoa。如：

把整数123打印成一个字符串保存在s中：

sprintf(s,"%d", 123);   //产生"123"

可以指定宽度，不足的左边补空格：

sprintf(s,"%8d%8d", 123, 4567); //产生："    123   4567"

当然也可以左对齐：

sprintf(s,"%-8d%8d", 123, 4567); //产生："123        4567"

也可以按照16进制打印：

sprintf(s,"%8x", 4567); //小写16进制，宽度占8个位置，右对齐

sprintf(s,"%-8X", 4568); //大写16进制，宽度占8个位置，左对齐

左边补0：

sprintf(s,"%08X", 4567); //产生："000011D7"

也可以按照8进制打印：

sprintf(s,"%8o", 4567); //8进制，宽度占8个位置，右对齐

b.      控制浮点数打印格式

浮点数使用格式符”%f”控制，默认保留小数点后6位数字，比如：

sprintf(s,"%f", 3.1415926);    //产生"3.141593"

”%m.nf”格式，其中m表示打印的宽度，n表示小数点后的位数。比如：

sprintf(s,"%10.3f",3.1415626);   //产生："     3.142"

sprintf(s,"%-10.3f",3.1415626); //产生："3.142    "

sprintf(s,"%.3f", 3.1415626);//不指定总宽度，产生："3.142"

c.      连接字符串

char* who ="I";

char* whom ="CSDN";

sprintf(s,"%s love %s.", who, whom); //产生："I love CSDN. "

连接字符串（一段以’\0’结尾的字符数组或叫做字符缓冲)

char a1[] ={'A', 'B', 'C', 'D', 'E', 'F', 'G'};

char a2[] ={'H', 'I', 'J', 'K', 'L', 'M', 'N'};

sprintf(s,"%.7s%.7s", a1, a2);// 产生： "ABCDEFGHIJKLMN"

d.      打印地址信息

使用打印无符号整数的”%u”:

sprintf(s,"%u", &i);

用16进制:

sprintf(s,"%08X", &i);

对于地址打印，sprintf 提供了专门的”%p”：

sprintf(s,"%p", &i);

e.      利用sprintf的返回值

int len =sprintf(s, "%d", i);

对于正整数来说，len便等于整数i的10进制位数。

下面的是个完整的例子，产生10个[0, 100)之间的随机数，并将他们打印到一个字符数组s中，以逗号分隔开。

#include<stdio.h>

#include<time.h>

#include<stdlib.h>

int main() {

   srand(time(0));

   char s[64];

   int offset = 0;

   for(int i = 0; i < 10; i++) {

      offset += sprintf(s + offset, "%d,", rand() % 100);

   }

   s[offset - 1] = '\n';//将最后一个逗号换成换行符。

   printf(s);

   return 0;

}

f.      后记

 1. 格式化规定符 
    Turbo C2.0提供的格式化规定符如下: 
━━━━━━━━━━━━━━━━━━━━━━━━━━ 
   符号                  作用 
────────────────────────── 
    %d              十进制有符号整数 
    %u              十进制无符号整数 
    %f              浮点数 
    %s              字符串 
    %c              单个字符 
    %p              指针的值 
    %e              指数形式的浮点数 
    %x,%X          无符号以十六进制表示的整数 
    %o              无符号以八进制表示的整数 

    %g              自动选择合适的表示法 

#include <stdio.h>
int main( void )
{

   for(int i = 32; i <127; i++) {

   printf("[ %c ]: %3d 0x%#04X\n", i, i, i);

}

char  buffer[200], s[] = "computer", c = 'l';
int   i = 35, j;
float fp = 1.7320534f;

/* Format and print various data: */
j  = sprintf( buffer,     "\tString:    %s\n", s );
j += sprintf( buffer + j, "\tCharacter: %c\n", c );
   j += sprintf( buffer + j, "\tInteger:   %d\n", i );
   j += sprintf( buffer + j, "\tReal:      %f\n", fp );

printf( "Output:\n%s\ncharacter count = %d\n", buffer, j );
}

二.C++中的方法

C++的stringstream

·数字转字符串：

#include<sstream>
#include<string>
string num2str(double i)
{
    stringstream ss;
    ss << i;
    return ss.str();//或者ss >> res;
}

·字符串转数字：

#include<sstream>
#include<string>
int str2num(string s)
{
    int num;
    stringstream ss(s);
    ss >> num;
    return num;
}

int main(){
    string a = "123.32";
    double res;
    stringstream ss;
    ss << a;
    ss >> res;
    return 0;
}