C++数值与字符串相互转换

from: http://blog.youkuaiyun.com/w343051232/article/details/7076188

以前一门心思搞算法，这个东西觉得自己写个函数就能实现的事，但是到了公司后才发现同事写的代码里面，调用各种库函数、window API、流来实现。什么都不懂的我表示鸭梨很大，今天翻了翻资料了解了下各种方法的使用方法、区别以及适用范围，写成了这篇又长又臭又没条理的东西。

注：以下字符串均特指空终止的字符串（字符串以'\0‘（一个字节的0）结束，宽字符串（本文中指UTF-8不涉及UTF-16及其他）以‘\0’（两个字节的0））

1.字符串转换为数值

1.1使用现成c库函数将10进制字符串转换为数值（c库函数不提供其他进制转换）

所属头文件<cstdlib>

atoi()、_wtoi()、atol()、_wtol()、atof()、_wtol()、_atoi64()、_wtoi64()，_w打头为相应宽字符版本不逐一介绍。

atoi()函数原型如下，将字符串转换为int类型

[cpp] view plain copy

1. int   atoi(   const   char   *string);  

_wtoi()函数原型如下，将宽字符串转换为int类型

[cpp] view plain copy

1. int _wtoi(const wchar_t *);  

atol()函数原型如下，将字符串转化为long

[cpp] view plain copy

1. long  atol(const char *);  

atof()函数原型如下，将字符串转化为doulbe

[cpp] view plain copy

1. double atof(const char *);  

_atoi64()函数原型如下，将字符串转化为__int64(long long int)

[cpp] view plain copy

1. __int64 _atoi64(const char *);  

例如：

[cpp] view plain copy

1. #include <windows.h>  
2. #include <iostream>  
3. #include <cstdlib>  
4. using namespace std;  
5.   
6. int main()  
7. {  
8.       
9.     char szBuff[100]="1000.2121";  
10.     int iTest = 0;  
11.     double dTest = 0.0;  
12.     long lTest = 0;  
13.     __int64 i64Test = 0;  
14.     iTest = atoi(szBuff);  
15.     dTest = atof(szBuff);  
16.     lTest = atol(szBuff);  
17.     i64Test = _atoi64(szBuff);  
18.         printf("iTest = %d\n",iTest);  
19.     printf("lTest = %ld\n",lTest);  
20.     printf("dTest = %lf\n",dTest);  
21.     printf("i64Test = %I64d\n",i64Test);  
22.     return 0;  
23. }  

输出结果：

[cpp] view plain copy

1. iTest = 1000  
2. lTest = 1000  
3. dTest = 1000.212100  
4. i64Test = 1000  

1.2使用现成Windows API将字符串转换为数值（Windows API 不提供浮点类型的转换，不支持64位整数）

1.2.1使用现成Windows API将10进制字符串转换为数值

所属头文件<shlwapi.h>

注：使用时注意引入"shlwapi.lib"

 StrToInt()(Widows一个兼容的函数，当定义了UNICODE时表示StrToIntW,否则表示StrToIntA,以下不一一列举)、StrToLong

 StrToInt()函数原型如下，将字符串转换为int（以下均一ANSI字符串为例，UNICODE不再列举）

[cpp] view plain copy

1. int    StrToIntA(LPCSTR lpSrc);  

StrToLong()函数原型如下，将字符串转换为long（其实Windows 32位机器int和long没区别）

[cpp] view plain copy

1. #define StrToLong               StrToInt  

1.2.1使用现成Windows API将10或者16进制字符串转换为数值（不支持浮点类型，不支持64位整数）

所属头文件<shlwapi.h>

注：使用时注意引入"shlwapi.lib"

StrToIntEx。（注：无StrToLongEx）

StrToIntEx函数原型如下，将任意进制字符串转换为int类型，转换成功返回TRUE，否则为FALSE

[cpp] view plain copy

1. BOOL    StrToIntExA(LPCSTR pszString, DWORD dwFlags, int FAR * piRet);  

第一个参数表示待转换的字符串，第二个字符串用来表示待转换的字符串是16进制还是10进制，当dwFlags为 STIF_DEFAULT表示10进制，当dwFlags为

STIF_SUPPORT_HEX时表示10进制。第三个参数代表一个指向int的指针（指向转换后的值）

例如：

[cpp] view plain copy

1. #include <windows.h>  
2. #include <iostream>  
3. #include <cstdlib>  
4. #include <shlwapi.h>  
5. using namespace std;  
6.   
7. #pragma comment(lib,"shlwapi.lib")  
8.   
9. int main()  
10. {  
11.       
12.     int   value;  
13.     char szHex[100] = "0xFF";  
14.         StrToIntExA(szHex,STIF_SUPPORT_HEX,&value);  
15.     printf("%d\n",value);  
16.     return 0;  
17. }  

输出结果为：

[cpp] view plain copy

1. 255  

1.3使用流将字符串转换为数值（64位流操作不支持，支持10进制，16进制，8进制）以ANSI为例

所属头文件<sstream>

预定义以下宏

[cpp] view plain copy

1. #define MY_OCT 1  //8进制  
2. #define MY_DEC 2  //10进制  
3. #define MY_HEX 3 //16进制  

通过自定义函数来说明：myStrToIntExA()、myStrToLongExA()、myStrToDoubleA()。（double类型仅支持10进制）

myStrToIntExA()函数如下，将字符串转int

[cpp] view plain copy

1. int myStrToIntExA(char *s,const int &iFlags = MY_DEC)  
2. {     
3.     int num;  
4.     stringstream ss(s);  
5.     switch (iFlags)  
6.     {  
7.     case MY_OCT:  
8.         ss>>std::oct>>num;//8进制  
9.         break;  
10.     case MY_DEC:  
11.         ss>>std::dec>>num;//10  
12.         break;  
13.     case MY_HEX:  
14.         ss>>std::hex>>num;  
15.         break;  
16.     default:  
17.         break;  
18.     }  
19.     return num;  
20. }  

myStrToLongExA() 函数如下，将字符串转long

[cpp] view plain copy

1. long myStrToLongExA(char *s,const int &iFlags = MY_DEC)  
2. {  
3.     long num;  
4.     stringstream ss(s);  
5.     switch (iFlags)  
6.     {  
7.     case MY_OCT:  
8.         ss>>std::oct>>num;//8进制  
9.         break;  
10.     case MY_DEC:  
11.         ss>>std::dec>>num;//10  
12.         break;  
13.     case MY_HEX:  
14.         ss>>std::hex>>num;  
15.         break;  
16.     default:  
17.         break;  
18.     }  
19.     return num;  
20. }  

myStrToDoubleA() 函数如下，将字符串转double

[cpp] view plain copy

1. double myStrToDoulbeA(char *s)  
2. {     
3.     double num;  
4.     stringstream ss(s);  
5.     ss>>num;  
6.     return num;  
7. }  

例如：

[cpp] view plain copy

1. #include <sstream>  
2. #include <iostream>  
3. using namespace std;  
4. #define MY_OCT 1  //8进制  
5. #define MY_DEC 2  //10进制  
6. #define MY_HEX 3 //16进制  
7.   
8. int myStrToIntExA(char *s,const int &iFlags = MY_DEC)  
9. {     
10.     int num;  
11.     stringstream ss(s);  
12.     switch (iFlags)  
13.     {  
14.     case MY_OCT:  
15.         ss>>std::oct>>num;//8进制  
16.         break;  
17.     case MY_DEC:  
18.         ss>>std::dec>>num;//10  
19.         break;  
20.     case MY_HEX:  
21.         ss>>std::hex>>num;  
22.         break;  
23.     default:  
24.         break;  
25.     }  
26.     return num;  
27. }  
28. double myStrToDoulbeA(char *s)  
29. {     
30.     double num;  
31.     stringstream ss(s);  
32.     ss>>num;  
33.     return num;  
34. }  
35. long myStrToLongExA(char *s,const int &iFlags = MY_DEC)  
36. {  
37.     long num;  
38.     stringstream ss(s);  
39.     switch (iFlags)  
40.     {  
41.     case MY_OCT:  
42.         ss>>std::oct>>num;//8进制  
43.         break;  
44.     case MY_DEC:  
45.         ss>>std::dec>>num;//10  
46.         break;  
47.     case MY_HEX:  
48.         ss>>std::hex>>num;  
49.         break;  
50.     default:  
51.         break;  
52.     }  
53.     return num;  
54. }  
55.   
56. int main()  
57. {  
58.          char str[] = "11";    
59.      int  iTest = myStrToIntExA(str,MY_HEX);  
60.      long lTest = myStrToLongExA(str,MY_HEX);  
61.      double dTest = myStrToDoulbeA(str);  
62.          printf("%d\n",iTest);  
63.      printf("%ld\n",lTest);  
64.      printf("%lf\n",dTest);  
65.      return 0;  
66. }  

输出结果：

[cpp] view plain copy

1. 17  
2. 17  
3. 11.000000  

3种方法的优劣如下表所示

	64位整数	浮点数	2进制	宽字符	8进制	10进制	16进制	特点
库函数	支持	支持	不支持	支持	不支持	支持	不支持	效率高
windows API	不支持	不支持	不支持	支持	不支持	支持	支持	效率较高
流	不支持	仅支持10进制	不支持	支持	支持	支持	支持	效率较低

总体来说

库函数唯一支持64位整数，效率高，

windows API 兼容性好，效率较高

流 支持进制多且支持10进制浮点转换，但是效率不高。

如果想支持非10进制的64位整数和浮点数，只能乖乖自己实现了，建议用第一种方式进行进制转换就OK了