将一个十六进制字符串转换为十进制数值的问题

//将1个字符转换为16进制数字
//chr:字符,0~9/A~F/a~F
//返回值:chr对应的16进制数值
u8 chr2hex(u8 chr)
{
	if(chr>='0'&&chr<='9')return chr-'0';
	if(chr>='A'&&chr<='F')return (chr-'A'+10);
	if(chr>='a'&&chr<='f')return (chr-'a'+10); 
	return 0;
}
//将1个16进制数字转换为字符
//hex:16进制数字,0~15;
//返回值:字符
u8 hex2chr(u8 hex)
{
	if(hex<=9)return hex+'0';
	if(hex>=10&&hex<=15)return (hex-10+'A'); 
	return '0';
}

以下转自：http://blog.csdn.net/delphiwcdj/article/details/4649854/

在程序中，我们有时需要将一个十六进制字符串转换为十进制数字。比如：
char *ptr="0x11";
int n=0;
//我们想让n等于0x11，即17

通常我们在C中，想将一个字符串转换为一整形数字，通常会使用下面的方法：

1. char *ptr="123";      
2. int n=0;  
3. n=atoi(ptr);  
4. printf("%d/n",n);  
5. //输出：123  

但是atoi库函数只能将十进制字符串转化为int整形，比如下面的例子：

1. #include <stdlib.h>   
2. #include <stdio.h>//atoi头文件   
3. int main(void)   
4. {   
5.    int n;   
6.    char *str = "12345.67";   
7.    n = atoi(str); //int atoi(const char *nptr);   
8.    printf("string = %s integer = %d/n", str, n);   
9.    return 0;   
10. }  
11. /*输出： 
12.   string = 12345.67 integer = 12345 
13. */  

所以要用atoi函数将"0x11"转化为十进制整形17是不行的。如果用的话，会输出下面的结果：

1. int n;   
2. char *str = "0x11";   
3. n = atoi(str); //返回值n等于0 (显然不是我们想要的结果)  

那怎么办呢？这时有人会想，那好办，我们自己写个函数转化下就行了，比如用下面的方法：
注意：我们用VC 6.0建了一个Win32控制台程序，为了方便，程序中使用了CString类型变量，需要做一点修改。
(1)包含afx.h头文件
(2)在Project->Settings->General->Mircosoft Foundation Classes中，选择Use MFC in a Shared DLL
然后我们就可以在Win32控制台下使用CString变量了，否则会出现编译错误。

1. #include <iostream>  
2. #include <afx.h>  
3. int ChangeNum(CString str,int length)     
4. {     
5.     char  revstr[16]={0};  //根据十六进制字符串的长度，这里注意数组不要越界  
6.     int   num[16]={0};     
7.     int   count=1;     
8.     int   result=0;     
9.     strcpy(revstr,str);     
10.     for   (int i=length-1;i>=0;i--)     
11.     {     
12.         if ((revstr[i]>='0') && (revstr[i]<='9'))     
13.             num[i]=revstr[i]-48;//字符0的ASCII值为48  
14.         else if ((revstr[i]>='a') && (revstr[i]<='f'))     
15.             num[i]=revstr[i]-'a'+10;     
16.         else if ((revstr[i]>='A') && (revstr[i]<='F'))     
17.             num[i]=revstr[i]-'A'+10;     
18.         else     
19.             num[i]=0;   
20.         result=result+num[i]*count;     
21.         count=count*16;//十六进制(如果是八进制就在这里乘以8)      
22.     }     
23.     return result;     
24. }  
25. int main()  
26. {  
27.     CString   str="0x11";   
28.     int n=0;  
29.     n=ChangeNum(str,str.GetLength());  
30.     printf("%d/n",n);  
31.         return 0;     
32. }  
33. /*输出： 
34.   17 
35. */  

是的，上面方法可以得到我们想要的值。还有更简单的方法吗？当然有！

 

方法1:

1. #include <stdio.h>  
2. int main()  
3. {  
4.     char   szValue[]  =   "0x11";     
5.     int    nValude    =   0;         
6.     sscanf(szValue,"%x",&nValude);     
7.     printf("%d/n",nValude);  
8.     return 0;     
9. }  
10. /*输出： 
11.   17 
12. */  

主要用到sscanf这个库函数：
函数名: sscanf 
功  能: 执行从字符串中的格式化输入 
用  法: int sscanf(char *string, char *format[,argument,...]); //%x就是我们要格式化的类型，即输出十六进制

 

方法2:

1. #include <stdio.h>  
2. #include <stdlib.h>//strtol头文件  
3. int main()  
4. {  
5.     char *p="0x11";     
6.     char *str;     
7.     int i = (int)strtol(p, &str, 16);//十六进制  
8.     printf("%d/n",i);  
9.     return 0;     
10. }  
11. /*输出： 
12.   17 
13. */  

主要用到strtol这个库函数，它的使用方法是：

函数名: strtol 
功  能: 将串转换为长整数 
用  法: long strtol(char *str, char **endptr, int base);//base指明我们要转换为几进制数
程序例:

1. #include <stdlib.h>   
2. #include <stdio.h>   
3. int main(void)   
4. {   
5.    char *string = "0x11", *endptr;   
6.    long lnumber;   
7.    /* strtol converts string to long integer */   
8.    lnumber = strtol(string, &endptr, 16);   
9.    printf("string = %s  long = %ld/n", string, lnumber);   
10.    return 0;   
11. }   
12. /*输出： 
13.   string = 0x11 long = 17 
14. */  

在VC 6.0的MFC程序中，我们有时要转换句柄就可以用strtol这个函数，比如：

1. HANDLE handle = (HANDLE)strtol(str,NULL, 16);  

PS:句柄是什么？

句柄就是用来区分各种内存对象的唯一标识符号，是个32位整数。
有些是整个系统唯一(如窗口句柄)，有些是当前进程或线程中唯一(如线程句柄，全局的有另一个标识符)。

详细的可分为许多种，都是以H开头的。在VB中使用时全部都用Long。
常见的有窗口句柄(HWND)，设备描述表句柄(HDC)，内存句柄(HMEM)，文件句柄，进程句柄，线程句柄，笔的类型句柄(HPEN)，字体句柄(HFONT)，区域句柄(HRGN)等等。

在申请句柄时是要占用资源的，分三类SYSTEM、USER、GDI。而WINDOWS的资源是固定的，并不随内存的扩大而扩大，所以使用完以后一定要释放。

方法3:

在网上，还看到一位朋友提出一种方法，就是读写INI文件(我认为这种方法效率太低，毕竟要读写文件的)，也将其摘录如下：

1. //存储HANDLE  
2. struct Tag_STRUCT  
3.     {  
4.         HWND hWnd;  
5.     } ;  
6.     struct Tag_STRUCT Struct;  
7.     Struct.hWnd = m_hWnd;  
8.     //把包含句柄的结构体写入ini文件  
9.     WritePrivateProfileStruct("Section","Key",&Struct,sizeof(Struct),"C://1.ini");  
10. //读取HANDLE  
11.     struct Tag_STRUCT  
12.     {  
13.         HWND hWnd;  
14.     } ;  
15.     struct Tag_STRUCT Struct;  
16.     //从包含句柄的结构体的ini文件读取HANDLE  
17.     GetPrivateProfileStruct("Section","Key",&Struct,sizeof(Struct),"C://1.ini");  

以上是我目前所知道的可以将十六进制的字符串转化为整形数值的方法，可能还有更合适的方法，也请看到此篇文章的朋友帮忙留言添加，谢过！