关闭

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

标签: hexdstinclude
514人阅读 评论(0) 收藏 举报
分类:
  1. 原文地址::::http://01258.blog.51cto.com/2229941/473635
  2. include <stdio.h>
  3. #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;

  19.         for(i=0; i<length; i++)
  20.          {
  21.                  dst[i] = src[i]^0xFF;
  22.          }
  23.         return 0;
  24. }

  25. //////////////////////////////////////////////////////////
  26. //
  27. //功能:十六进制转为十进制
  28. //
  29. //输入:const unsigned char *hex          待转换的十六进制数据
  30. //       int length                        十六进制数据长度
  31. //
  32. //输出:
  33. //
  34. //返回:int   rslt                         转换后的十进制数据
  35. //
  36. //思路:十六进制每个字符位所表示的十进制数的范围是0 ~255,进制为256
  37. //       左移8位(<<8)等价乘以256
  38. //
  39. /////////////////////////////////////////////////////////
  40. unsigned long HextoDec(const unsigned char *hex, int length)
  41. {
  42.     int i;
  43.      unsigned long rslt = 0;

  44.     for(i=0; i<length; i++)
  45.      {
  46.          rslt += (unsigned int)(hex[i])<<(8*(length-1-i));
  47.                                                         
  48.      }

  49.     return rslt;
  50. }


  51. /////////////////////////////////////////////////////////
  52. //
  53. //功能:十进制转十六进制
  54. //
  55. //输入:int dec                      待转换的十进制数据
  56. //       int length                   转换后的十六进制数据长度
  57. //
  58. //输出:unsigned char *hex           转换后的十六进制数据
  59. //
  60. //返回:0     success
  61. //
  62. //思路:原理同十六进制转十进制
  63. //////////////////////////////////////////////////////////
  64. int DectoHex(int dec, unsigned char *hex, int length)
  65. {
  66.     int i;

  67.     for(i=length-1; i>=0; i--)
  68.      {
  69.          hex[i] = (dec%256)&0xFF;
  70.          dec /= 256;
  71.      }

  72.     return 0;
  73. }

  74. /////////////////////////////////////////////////////////
  75. //
  76. //功能:求权
  77. //
  78. //输入:int base                     进制基数
  79. //       int times                    权级数
  80. //
  81. //输出:
  82. //
  83. //返回:unsigned long                当前数据位的权
  84. //
  85. //////////////////////////////////////////////////////////
  86. unsigned long power(int base, int times)
  87. {
  88.     int i;
  89.      unsigned long rslt = 1;

  90.     for(i=0; i<times; i++)
  91.          rslt *= base;

  92.     return rslt;
  93. }

  94. /////////////////////////////////////////////////////////
  95. //
  96. //功能:BCD转10进制
  97. //
  98. //输入:const unsigned char *bcd      待转换的BCD码
  99. //       int length                    BCD码数据长度
  100. //
  101. //输出:
  102. //
  103. //返回:unsigned long                当前数据位的权
  104. //
  105. //思路:压缩BCD码一个字符所表示的十进制数据范围为0 ~ 99,进制为100
  106. //       先求每个字符所表示的十进制值,然后乘以权
  107. //////////////////////////////////////////////////////////
  108. unsigned long   BCDtoDec(const unsigned char *bcd, int length)
  109. {
  110.      int i, tmp;
  111.       unsigned long dec = 0;

  112.      for(i=0; i<length; i++)
  113.       {
  114.          tmp = ((bcd[i]>>4)&0x0F)*10 + (bcd[i]&0x0F);   
  115.          dec += tmp * power(100, length-1-i);          
  116.       }

  117.      return dec;
  118. }

  119. /////////////////////////////////////////////////////////
  120. //
  121. //功能:十进制转BCD码
  122. //
  123. //输入:int Dec                       待转换的十进制数据
  124. //       int length                    BCD码数据长度
  125. //
  126. //输出:unsigned char *Bcd            转换后的BCD码
  127. //
  128. //返回:0   success
  129. //
  130. //思路:原理同BCD码转十进制
  131. //
  132. //////////////////////////////////////////////////////////
  133. int DectoBCD(int Dec, unsigned char *Bcd, int length)
  134. {
  135.      int i;
  136.      int temp;

  137.      for(i=length-1; i>=0; i--)
  138.       {
  139.           temp = Dec%100;
  140.           Bcd[i] = ((temp/10)<<4) + ((temp%10) & 0x0F);
  141.           Dec /= 100;
  142.       }

  143.      return 0;
  144. }

  145. int main()
  146. {
  147.     register int i;
  148.      unsigned char tmp_bff[12] = "";

  149.     //十六进制转十进制
  150.      unsigned char HEX[4] = {0x34, 0xFE, 0x3E, 0xFF};
  151.      unsigned long dec_hex = 0;

  152.      dec_hex = HextoDec(HEX, 4);
  153.     
  154.      printf("dec_hex = %d\n", dec_hex);

  155.     //十进制转十六进制
  156.      DectoHex(dec_hex, tmp_bff, 4);
  157.     for(i=0; i<5; i++)
  158.      {
  159.          printf("tmp_bff[%d] = 0x%02X\n",i, tmp_bff[i]);
  160.      }

  161.     //BCD码转十进制
  162.      unsigned long dec_bcd = 0;
  163.      unsigned char BCD[4] = {0x98, 0x23, 0x45, 0x78};

  164.      dec_bcd = BCDtoDec(BCD, 4);
  165.      printf("dec_bcd = %d\n", dec_bcd);

  166.     //十进制转BCD码
  167.      DectoBCD(dec_bcd, tmp_bff, 4);
  168.     for(i=0; i<5; i++)
  169.      {
  170.          printf("tmp_bff[%d] = 0x%02X\n", i, tmp_bff[i]);
  171.      }

  172.      getchar();
    1. }
    2. 4月30日
    3. 16进制、10进制、BCD码之间的转换

    1. #include <stdio.h>
    2. #include <string.h>

    3. /////////////////////////////////////////////////////
    4. //
    5. //功能:二进制取反
    6. //
    7. //输入:const unsigned char *src   二进制数据
    8. //       int length                 待转换的二进制数据长度
    9. //
    10. //输出:unsigned char *dst         取反后的二进制数据
    11. //
    12. //返回:0     success
    13. //
    14. //////////////////////////////////////////////////////
    15. int convert(unsigned char *dst, const unsigned char *src, int length)
    16. {
    17.         int i;

    18.         for(i=0; i<length; i++)
    19.          {
    20.                  dst[i] = src[i]^0xFF;
    21.          }
    22.         return 0;
    23. }

    24. //////////////////////////////////////////////////////////
    25. //
    26. //功能:十六进制转为十进制
    27. //
    28. //输入:const unsigned char *hex          待转换的十六进制数据
    29. //       int length                        十六进制数据长度
    30. //
    31. //输出:
    32. //
    33. //返回:int   rslt                         转换后的十进制数据
    34. //
    35. //思路:十六进制每个字符位所表示的十进制数的范围是0 ~255,进制为256
    36. //       左移8位(<<8)等价乘以256
    37. //
    38. /////////////////////////////////////////////////////////
    39. unsigned long HextoDec(const unsigned char *hex, int length)
    40. {
    41.     int i;
    42.      unsigned long rslt = 0;

    43.     for(i=0; i<length; i++)
    44.      {
    45.          rslt += (unsigned int)(hex[i])<<(8*(length-1-i));
    46.                                                         
    47.      }

    48.     return rslt;
    49. }


    50. /////////////////////////////////////////////////////////
    51. //
    52. //功能:十进制转十六进制
    53. //
    54. //输入:int dec                      待转换的十进制数据
    55. //       int length                   转换后的十六进制数据长度
    56. //
    57. //输出:unsigned char *hex           转换后的十六进制数据
    58. //
    59. //返回:0     success
    60. //
    61. //思路:原理同十六进制转十进制
    62. //////////////////////////////////////////////////////////
    63. int DectoHex(int dec, unsigned char *hex, int length)
    64. {
    65.     int i;

    66.     for(i=length-1; i>=0; i--)
    67.      {
    68.          hex[i] = (dec%256)&0xFF;
    69.          dec /= 256;
    70.      }

    71.     return 0;
    72. }

    73. /////////////////////////////////////////////////////////
    74. //
    75. //功能:求权
    76. //
    77. //输入:int base                     进制基数
    78. //       int times                    权级数
    79. //
    80. //输出:
    81. //
    82. //返回:unsigned long                当前数据位的权
    83. //
    84. //////////////////////////////////////////////////////////
    85. unsigned long power(int base, int times)
    86. {
    87.     int i;
    88.      unsigned long rslt = 1;

    89.     for(i=0; i<times; i++)
    90.          rslt *= base;

    91.     return rslt;
    92. }

    93. /////////////////////////////////////////////////////////
    94. //
    95. //功能:BCD转10进制
    96. //
    97. //输入:const unsigned char *bcd      待转换的BCD码
    98. //       int length                    BCD码数据长度
    99. //
    100. //输出:
    101. //
    102. //返回:unsigned long                当前数据位的权
    103. //
    104. //思路:压缩BCD码一个字符所表示的十进制数据范围为0 ~ 99,进制为100
    105. //       先求每个字符所表示的十进制值,然后乘以权
    106. //////////////////////////////////////////////////////////
    107. unsigned long   BCDtoDec(const unsigned char *bcd, int length)
    108. {
    109.      int i, tmp;
    110.       unsigned long dec = 0;

    111.      for(i=0; i<length; i++)
    112.       {
    113.          tmp = ((bcd[i]>>4)&0x0F)*10 + (bcd[i]&0x0F);   
    114.          dec += tmp * power(100, length-1-i);          
    115.       }

    116.      return dec;
    117. }

    118. /////////////////////////////////////////////////////////
    119. //
    120. //功能:十进制转BCD码
    121. //
    122. //输入:int Dec                       待转换的十进制数据
    123. //       int length                    BCD码数据长度
    124. //
    125. //输出:unsigned char *Bcd            转换后的BCD码
    126. //
    127. //返回:0   success
    128. //
    129. //思路:原理同BCD码转十进制
    130. //
    131. //////////////////////////////////////////////////////////
    132. int DectoBCD(int Dec, unsigned char *Bcd, int length)
    133. {
    134.      int i;
    135.      int temp;

    136.      for(i=length-1; i>=0; i--)
    137.       {
    138.           temp = Dec%100;
    139.           Bcd[i] = ((temp/10)<<4) + ((temp%10) & 0x0F);
    140.           Dec /= 100;
    141.       }

    142.      return 0;
    143. }

    144. int main()
    145. {
    146.     register int i;
    147.      unsigned char tmp_bff[12] = "";

    148.     //十六进制转十进制
    149.      unsigned char HEX[4] = {0x34, 0xFE, 0x3E, 0xFF};
    150.      unsigned long dec_hex = 0;

    151.      dec_hex = HextoDec(HEX, 4);
    152.     
    153.      printf("dec_hex = %d\n", dec_hex);

    154.     //十进制转十六进制
    155.      DectoHex(dec_hex, tmp_bff, 4);
    156.     for(i=0; i<5; i++)
    157.      {
    158.          printf("tmp_bff[%d] = 0x%02X\n",i, tmp_bff[i]);
    159.      }

    160.     //BCD码转十进制
    161.      unsigned long dec_bcd = 0;
    162.      unsigned char BCD[4] = {0x98, 0x23, 0x45, 0x78};

    163.      dec_bcd = BCDtoDec(BCD, 4);
    164.      printf("dec_bcd = %d\n", dec_bcd);

    165.     //十进制转BCD码
    166.      DectoBCD(dec_bcd, tmp_bff, 4);
    167.     for(i=0; i<5; i++)
    168.      {
    169.          printf("tmp_bff[%d] = 0x%02X\n", i, tmp_bff[i]);
    170.      }

    171.      getchar();
    172. }
  • 0
    0

    查看评论
    * 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
      个人资料
      • 访问:205467次
      • 积分:2372
      • 等级:
      • 排名:第16235名
      • 原创:13篇
      • 转载:134篇
      • 译文:1篇
      • 评论:22条
      最新评论