bcd码

BCD码   binary-coded decimal  简称为BCD码或者二-十进制代码，也称为  二进制码十进制数。是一种二进制的数字编码形式，用二进制编码的十进制代码。这种编码形式利用了四个位元来存储一个十进制的数码，使二进制和十进制之间的转换得以快捷的进行。

简介编辑：由于十进制数共有0 1 2 ...9十个数码，因此至少需要4位二进制码来表示1位十进制数。在使用BCD编码时一定要注意其有效的编码仅十个，即0000-1001  四位二进制数的其余六个编码1010   1011  1100  1101  1110   1111不是有效编码。常见BCD编码有8421码，2421bcd码  余3码对应编码表如下 

0　　0000

1　　0001

2　　0010

3　　0011

...

9　　1001

 

 

ASCII  american  standard code for information interchange   美国信息交换标准代码  是基于拉丁字母的一套电脑编码系统   主要用于显示现代英语和其他西欧语言  是现今最通用的单字节编码系统   并等同于国际标准   ISO/IEC 646.

 

压缩和非压缩bcd码

　　用二进的数来表示十进制的数字   对于数，在计算机总是用一定位数的二进制数字来表示。因此，对于一个十进制数例如6，我们可以用一个8位二进制数来表示就是00000110b    这就是非压缩的bcd码

　　而用4位二进制数来表示就是0110b  这就是压缩bcd码。压缩就是少了4个0

　　例如十进制数36：非压缩为00000011   00000110   ；而压缩的bcd码表示为0011  0110 .其中00000011和0011都代表3  、00000110和0110代表6  以此类推。

　　　　

压缩bcd码  也叫组合bcd码  就是将两位十进制数   存放在一个字节当中  ，例如82就是1000 0010

 

运算法则

 对二进制的加法运算的结果采用 加6修正，这种修正称为BCD调整。即将二进制加法运算的结果修正为bcd码加法运算的结果，两个两位bcd数相加时，的修正规则

　　1.如果任何两个对应位bcd数相加的结果向高一位无进位 ，若得到的结果小于或等于9，则该不需要修正

　　2.如果得到的结果大于9小于16时，该位进行加6修正。

　　3.如果任何两个对应位bcd数相加的结果向高一位有进位时，即结果大于或等于16  该位进行加6修正，

　　4.低位修正结果使高位大于9时，高位进行加6修正。

　　例1：两个bcd码的十进制数位36和 26 相加的结果是62

　　　　36：0011　　0110

　　　　26：0010　　0110

　　相加得：0101　　1100   　　结果不正确  所以需要在低4位再加上6即0110

　　　　　　　　　　 0110　　　产生向高处的进位

　　得：　　0110　　0010   　　代表十进制的bcd码为62

 

　　例2：19加19

　　0001　　1001

　　0001　　1001

相加0011　　0010  再加6

　　0011　　0110  结果为38

 

bcd码的减法运算

　　两个组合bcd码 进行减法运算时，当低位向高位有错位时，由于借1作16与借1作10的差别，将比正确的结果多6，所以有借位时，可采用减6修正法来修正，

两个bcd码相加减时，先按二进制加减指令进行运算，再对结果用bcd码调整指令进行调整，就可以得到正确的十进制运算结果。实际上，计算机中既有组合bcd数的调整指令，也有分离bcd数的调整指令。

另外bcd码的加减运算，也可以在运算前有程序先变换成二进制数，然后由计算机对二进制数运算处理，然后由计算机对二进制数运算处理，再将二进制数的结果由程序转换为BCD码。

 

 

6、C语言压缩bcd码

 

[cpp] view plain copy
 
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. #include<string.h>  
  4.    
  5.    
  6. /* 
  7. * 字符串转成bcd码，这个是正好偶数个数据的时候，如果是奇数个数据则分左靠还是右靠压缩BCD码 
  8. */  
  9. intasc_to_bcd(char * dest,const char *src)  
  10. {  
  11.        unsigned char temp;  
  12.        while(*src !='\0')  
  13.        {  
  14.               temp = *src;  
  15.               *dest |=((temp&0xf)<<4);  
  16.               src++;  
  17.               temp = *src;  
  18.               *dest |= (temp&0xf);  
  19.               src++;  
  20.               dest++;  
  21.        }  
  22.        return 0;  
  23. }  
  24.    
  25. intasc_to_bcd_right(char *dest,const char *src,int src_len)  
  26. {  
  27.        unsigned char temp;  
  28.        if((src_len %2) !=0)  
  29.        {  
  30.               *dest &= 0;  
  31.               temp = *src;  
  32.               *dest |= (temp&0xf);  
  33.               src++;  
  34.               dest++;  
  35.        }  
  36.        asc_to_bcd(dest,src);  
  37.        return 0;  
  38. }  
  39.    
  40. intasc_to_bcd_left(char *dest,const char *src,int src_len)  
  41. {  
  42.        unsigned char temp;  
  43.        if((src_len %2) !=0)  
  44.        {  
  45.               dest[src_len-1] &=0;  
  46.        }  
  47.        asc_to_bcd(dest,src);  
  48.        return 0;  
  49. }  
  50.    
  51. voidprint_hex(char * bcd,int len)  
  52. {  
  53.        int i=0;  
  54.        for(i=0;i<len;i++)  
  55.        {  
  56.               int n = 8;  
  57.               while(n--){  
  58.                      if((bcd[i] &(0x1<<n))==0)  
  59.                             printf("0");  
  60.                      else  
  61.                             printf("1");  
  62.               }  
  63.               putchar('\n');  
  64.        }  
  65. }  
  66.    
  67.    
  68. intbcd_to_asc(char *dest,const char *src,int src_len)  
  69. {  
  70.        unsigned char temp;  
  71.        char *t = dest;  
  72.        while(src_len--)  
  73.        {  
  74.               *t |= ((*src&0xf0)>>4);  
  75.               *t++ |= 0x30;  
  76.               *t |= (*src&0xf);  
  77.               *t++ |= 0x30;  
  78.               src++;  
  79.        }  
  80.        return 0;  
  81. }  
  82.    
  83. intleft_bcd_to_asc(char *dest,const char * src,int src_len)  
  84. {  
  85.        bcd_to_asc(dest,src,src_len);  
  86.        dest[src_len*2 -1] = '\0';  
  87.    
  88.        return 0;  
  89. }  
  90.    
  91.    
  92. intright_bcd_to_asc(char *dest,const char * src,int src_len)  
  93. {  
  94.        bcd_to_asc(dest,src,src_len);  
  95.    
  96.        memmove(dest,dest+1,src_len*2-1);  
  97.        dest[src_len*2-1] = '\0';  
  98.        return 0;  
  99. }  
  100.    
  101.    
  102. int main(void)  
  103. {  
  104.        char str[100];  
  105.         
  106.        char *str1 = "1234567";  
  107.        int str_len = strlen(str1);  
  108.        int bcd_len = (str_len+1)/2;  
  109.        char *bcd = (char *)malloc(bcd_len);  
  110.        printf("str_len = %d\n",str_len);  
  111.        printf("bcd_len = %d\n",bcd_len);  
  112.        memset(bcd,0,bcd_len);  
  113.        memset(str,0,100);  
  114.    
  115. #if 0  
  116.        printf("右靠\n");  
  117.        asc_to_bcd_right(bcd,str1,str_len);  
  118.        print_hex(bcd,bcd_len);  
  119.        right_bcd_to_asc(str,bcd,bcd_len);  
  120.        printf("str = %s\n",str);  
  121. #endif  
  122.    
  123. #if 1  
  124.        printf("左靠\n");  
  125.        asc_to_bcd_left(bcd,str1,str_len);  
  126.        print_hex(bcd,bcd_len);  
  127.        //memset(str,0,100);  
  128.        left_bcd_to_asc(str,bcd,bcd_len);  
  129.        printf("str = %s\n",str);  
  130. #endif  
  131.        return 0;  
  132. }  

 

 

 

 

　　

 

posted on 2017-11-27 18:33  学习记录园  阅读(8041)  评论(0)  编辑  收藏  举报
Copyright © 2025 学习记录园
Powered by .NET 9.0 on Kubernetes Powered by: 博客园