16进制、10进制、BCD码之间的转换

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

• 1. }
  2. 4月30日

  3. 16进制、10进制、BCD码之间的转换

  1. #include <stdio.h>
  2. #include <string.h>
  3. 
     
  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;
  19. 
      
  20.         for(i=0; i<length; i++)
  21.          {
  22.                  dst[i] = src[i]^0xFF;
  23.          }
  24.         return 0;
  25. }
  26. 
      
  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;
  46. 
      
  47.     for(i=0; i<length; i++)
  48.      {
  49.          rslt += (unsigned int)(hex[i])<<(8*(length-1-i));
  50.                                                         
  51.      }
  52. 
      
  53.     return rslt;
  54. }
  55. 
      
  56. 
      
  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;
  73. 
      
  74.     for(i=length-1; i>=0; i--)
  75.      {
  76.          hex[i] = (dec%256)&0xFF;
  77.          dec /= 256;
  78.      }
  79. 
      
  80.     return 0;
  81. }
  82. 
      
  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;
  99. 
      
  100.     for(i=0; i<times; i++)
  101.          rslt *= base;
  102. 
       
  103.     return rslt;
  104. }
  105. 
       
  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;
  124. 
       
  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.       }
  130. 
       
  131.      return dec;
  132. }
  133. 
       
  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;
  152. 
       
  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.       }
  159. 
       
  160.      return 0;
  161. }
  162. 
       
  163. int main()
  164. {
  165.     register int i;
  166.      unsigned char tmp_bff[12] = "";
  167. 
       
  168.     //十六进制转十进制
  169.      unsigned char HEX[4] = {0x34, 0xFE, 0x3E, 0xFF};
  170.      unsigned long dec_hex = 0;
  171. 
       
  172.      dec_hex = HextoDec(HEX, 4);
  173.     
  174.      printf("dec_hex = %d\n", dec_hex);
  175. 
       
  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.      }
  182. 
       
  183.     //BCD码转十进制
  184.      unsigned long dec_bcd = 0;
  185.      unsigned char BCD[4] = {0x98, 0x23, 0x45, 0x78};
  186. 
       
  187.      dec_bcd = BCDtoDec(BCD, 4);
  188.      printf("dec_bcd = %d\n", dec_bcd);
  189. 
       
  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.      }
  196. 
       
  197.      getchar();
  198. }