在做嵌入式软件的设计中，常常会遇到十六进制、BCD码与十进制之间的转换，近期做M1卡的应用中，涉及了大量的十六进制、BCD码与十进制之间的转换。通过对BCD码、十六进制 权的理解，轻松的实现了他们之间的互换。

1. #include <stdio.h>
2. #include <string.h>
4. /
5. //
6. //功能：二进制取反
7. //
8. //输入：const unsigned char *src  二进制数据
9. //      int length                待转换的二进制数据长度
10. //
11. //输出：unsigned char *dst        取反后的二进制数据
12. //
13. //返回：0    success
14. //
15. //
16. int convert(unsigned char *dst, const unsigned char *src, int length)
17. {
18.         int i;
20.         for(i=0; i<length; i++)
21.         {
22.                 dst[i] = src[i]^0xFF;
23.         }
24.         return 0;
25. }
27. //
28. //
29. //功能：十六进制转为十进制
30. //
31. //输入：const unsigned char *hex         待转换的十六进制数据
32. //      int length                       十六进制数据长度
33. //
34. //输出：
35. //
36. //返回：int  rslt                        转换后的十进制数据
37. //
38. //思路：十六进制每一个字符位所表示的十进制数的范围是0 ~255，进制为256
39. //      左移8位(<<8)等价乘以256
40. //
41. /
42. unsigned long HextoDec(const unsigned char *hex, int length)
43. {
44.     int i;
45.     unsigned long rslt = 0;
47.     for(i=0; i<length; i++)
48.     {
49.         rslt += (unsigned long)(hex[i])<<(8*(length-1-i));
50.                                                         
51.     }
53.     return rslt;
54. }
57. /
58. //
59. //功能：十进制转十六进制
60. //
61. //输入：int dec                     待转换的十进制数据
62. //      int length                  转换后的十六进制数据长度
63. //
64. //输出：unsigned char *hex          转换后的十六进制数据
65. //
66. //返回：0    success
67. //
68. //思路：原理同十六进制转十进制
69. //
70. int DectoHex(int dec, unsigned char *hex, int length)
71. {
72.     int i;
74.     for(i=length-1; i>=0; i--)
75.     {
76.         hex[i] = (dec%256)&0xFF;
77.         dec /= 256;
78.     }
80.     return 0;
81. }
83. /
84. //
85. //功能：求权
86. //
87. //输入：int base                    进制基数
88. //      int times                   权级数
89. //
90. //输出：
91. //
92. //返回：unsigned long               当前数据位的权
93. //
94. //
95. unsigned long power(int base, int times)
96. {
97.     int i;
98.     unsigned long rslt = 1;
100.     for(i=0; i<times; i++)
101.         rslt *= base;
103.     return rslt;
104. }
106. /
107. //
108. //功能：BCD转10进制
109. //
110. //输入：const unsigned char *bcd     待转换的BCD码
111. //      int length                   BCD码数据长度
112. //
113. //输出：
114. //
115. //返回：unsigned long               当前数据位的权
116. //
117. //思路：压缩BCD码一个字符所表示的十进制数据范围为0 ~ 99,进制为100
118. //      先求每一个字符所表示的十进制值，然后乘以权
119. //
120. unsigned long  BCDtoDec(const unsigned char *bcd, int length)
121. {
122.      int i, tmp;
123.      unsigned long dec = 0;
125.      for(i=0; i<length; i++)
126.      {
127.         tmp = ((bcd[i]>>4)&0x0F)*10 + (bcd[i]&0x0F);   
128.         dec += tmp * power(100, length-1-i);          
129.      }
131.      return dec;
132. }
134. /
135. //
136. //功能：十进制转BCD码
137. //
138. //输入：int Dec                      待转换的十进制数据
139. //      int length                   BCD码数据长度
140. //
141. //输出：unsigned char *Bcd           转换后的BCD码
142. //
143. //返回：0  success
144. //
145. //思路：原理同BCD码转十进制
146. //
147. //
148. int DectoBCD(int Dec, unsigned char *Bcd, int length)
149. {
150.      int i;
151.      int temp;
153.      for(i=length-1; i>=0; i--)
154.      {
155.          temp = Dec%100;
156.          Bcd[i] = ((temp/10)<<4) + ((temp%10) & 0x0F);
157.          Dec /= 100;
158.      }
160.      return 0;
161. }
163. int main()
164. {
165.     register int i;
166.     unsigned char tmp_bff[12] = "";
168.     //十六进制转十进制
169.     unsigned char HEX[4] = {0x34, 0xFE, 0x3E, 0xFF};
170.     unsigned long dec_hex = 0;
172.     dec_hex = HextoDec(HEX, 4);
173.     
174.     printf("dec_hex = %d/n", dec_hex);
176.     //十进制转十六进制
177.     DectoHex(dec_hex, tmp_bff, 4);
178.     for(i=0; i<5; i++)
179.     {
180.         printf("tmp_bff[%d] = 0x%02X/n",i, tmp_bff[i]);
181.     }
183.     //BCD码转十进制
184.     unsigned long dec_bcd = 0;
185.     unsigned char BCD[4] = {0x98, 0x23, 0x45, 0x78};
187.     dec_bcd = BCDtoDec(BCD, 4);
188.     printf("dec_bcd = %d/n", dec_bcd);
190.     //十进制转BCD码
191.     DectoBCD(dec_bcd, tmp_bff, 4);
192.     for(i=0; i<5; i++)
193.     {
194.         printf("tmp_bff[%d] = 0x%02X/n", i, tmp_bff[i]);
195.     }
197.     getchar();
198. }

假设有其它的方法能够一起讨论