将十进制数/字符串转换为BCD码(将字符存入内存)

原文地址::http://www.kaixinwenda.com/article-MPowell-8657770.html

 

 

需求:将十进制数按字面数值直接存入内容,如int nDec=12,要存入byte b中,存入后b对应内存地址显示0x12;
分析:如直接使用b = nDec,会按照ACSII码值存值,b内存地址显示0x0c,不符合要求;而需要的0x12为十进制值18,因此可以先对int nDec进行转换;
实现:
(1)针对十进制数

法一:先将int nDec=12转换为十六进制值,再存入byte b中;

  1. #define BUF_LEN     10   
  2. char szBuf[BUF_LEN] = {0};  // 中间字符串  
  3. int nDec = 12;      // 原始十进制数据  
  4. int nHex = 0;       // 转换的十六进制数据  
  5. byte b = 0;     // 目标字符   
  6.   
  7. sprintf_s(szBuf, BUF_LEN, "%d", nDec);  // 十进制数据-->中间字符串  
  8. sscanf_s(szBuf, "%x", &nHex);   // 中间字符串-->十六进制数据  
  9.   
  10. b = nHex;           // 存入字符,获得结果  
	#define BUF_LEN		10
	char szBuf[BUF_LEN] = {0};	// 中间字符串
	int nDec = 12;		// 原始十进制数据
	int nHex = 0;		// 转换的十六进制数据
	byte b = 0;		// 目标字符

	sprintf_s(szBuf, BUF_LEN, "%d", nDec);	// 十进制数据-->中间字符串
	sscanf_s(szBuf, "%x", &nHex);	// 中间字符串-->十六进制数据

	b = nHex;			// 存入字符,获得结果

法二:假设数字最多有6位,用3字节表示

  1. byte* itoBCD(byte* const buf, int n)  
  2. {  
  3.     if (n < 0 || n > 999999)  
  4.     {  
  5.         return NULL;  
  6.     }  
  7.   
  8.     buf[0] = ((n / 100000) << 4) & 0xF0;  
  9.     n %= 100000;  
  10.     buf[0] |= (n / 10000) & 0x0F;  
  11.   
  12.     n %= 10000;  
  13.     buf[1] = ((n / 1000) << 4) & 0xF0;  
  14.     n %= 1000;  
  15.     buf[1] |= (n / 100) & 0x0F;  
  16.   
  17.     n %= 100;  
  18.     buf[2] = ((n / 10) << 4) & 0xF0;  
  19.     n %= 10;  
  20.     buf[2] |= n & 0x0F;  
  21.   
  22.     return buf;  
  23. }  
byte* itoBCD(byte* const buf, int n)
{
	if (n < 0 || n > 999999)
	{
		return NULL;
	}

	buf[0] = ((n / 100000) << 4) & 0xF0;
	n %= 100000;
	buf[0] |= (n / 10000) & 0x0F;

	n %= 10000;
	buf[1] = ((n / 1000) << 4) & 0xF0;
	n %= 1000;
	buf[1] |= (n / 100) & 0x0F;

	n %= 100;
	buf[2] = ((n / 10) << 4) & 0xF0;
	n %= 10;
	buf[2] |= n & 0x0F;

	return buf;
}

假设数字最多有12位,用6字节表示

  1. byte* itoBCD_6Bit(byte* const buf, int n)  
  2. {  
  3.     if (n < 0 || n > 999999)  
  4.     {  
  5.         return NULL;  
  6.     }  
  7.   
  8.     buf[0] = 0x00;  
  9.     buf[0] |= (n / 100000) & 0x0F;  
  10.   
  11.     n %= 100000;  
  12.     buf[1] = 0x00;  
  13.     buf[1] |= (n / 10000) & 0x0F;  
  14.   
  15.     n %= 10000;  
  16.     buf[2] = 0x00;  
  17.     buf[2] |= (n / 1000) & 0x0F;  
  18.   
  19.     n %= 1000;  
  20.     buf[3] = 0x00;  
  21.     buf[3] |= (n / 100) & 0x0F;  
  22.   
  23.     n %= 100;  
  24.     buf[4] = 0x00;  
  25.     buf[4] |= (n / 10) & 0x0F;  
  26.   
  27.     n %= 10;  
  28.     buf[5] = 0x00;  
  29.     buf[5] |= (n / 1) & 0x0F;  
  30.   
  31.   
  32.     return buf;  
  33. }  
byte* itoBCD_6Bit(byte* const buf, int n)
{
	if (n < 0 || n > 999999)
	{
		return NULL;
	}

	buf[0] = 0x00;
	buf[0] |= (n / 100000) & 0x0F;

	n %= 100000;
	buf[1] = 0x00;
	buf[1] |= (n / 10000) & 0x0F;

	n %= 10000;
	buf[2] = 0x00;
	buf[2] |= (n / 1000) & 0x0F;

	n %= 1000;
	buf[3] = 0x00;
	buf[3] |= (n / 100) & 0x0F;

	n %= 100;
	buf[4] = 0x00;
	buf[4] |= (n / 10) & 0x0F;

	n %= 10;
	buf[5] = 0x00;
	buf[5] |= (n / 1) & 0x0F;


	return buf;
}

(2)针对字符串

使用时注意:在传入字符串前需先明确字符串最大长度,然后在左侧完成补0

  1. void CharToBcd(char* Cbuf, byte* Bbuf, int* blen)  
  2. {  
  3.     int i = 0;  
  4.     int j = 0;  
  5.     int tem_len = 0;  
  6.     byte tem_h = 0;  
  7.     byte tem_l = 0;  
  8.   
  9.     tem_len = (int)strlen(Cbuf);  
  10.   
  11.     for (i=0; i<tem_len; i++)  
  12.     {  
  13.         switch (Cbuf[i])  
  14.         {  
  15.         case '0':  
  16.         case '1':  
  17.         case '2':  
  18.         case '3':  
  19.         case '4':  
  20.         case '5':  
  21.         case '6':  
  22.         case '7':  
  23.         case '8':  
  24.         case '9':  
  25.             Cbuf[i] = ((Cbuf[i] - 0x30) & 0x0f);  
  26.             break;  
  27.         case 'A':  
  28.         case 'a':  
  29.             Cbuf[i] = 0x0A;  
  30.             break;  
  31.         case 'B':  
  32.         case 'b':  
  33.             Cbuf[i] = 0x0B;  
  34.             break;  
  35.         case 'C':  
  36.         case 'c':  
  37.             Cbuf[i] = 0x0C;  
  38.             break;  
  39.         case 'D':  
  40.         case 'd':  
  41.             Cbuf[i] = 0x0D;  
  42.             break;  
  43.         case 'E':  
  44.         case 'e':  
  45.             Cbuf[i] = 0x0E;  
  46.             break;  
  47.         case 'F':  
  48.         case 'f':  
  49.             Cbuf[i] = 0x0F;  
  50.             break;  
  51.         default:  
  52.             break;  
  53.         }  
  54.     }  
  55.   
  56.     if ((tem_len % 2) == 0)  
  57.     {  
  58.         for (i=0,j=0; i<tem_len; i++,j++)  
  59.         {  
  60.             tem_h = (byte)(Cbuf[i]<<4) & 0xf0;  
  61.             tem_l = (byte)(Cbuf[++i] & 0x0f);  
  62.             Bbuf[j] = tem_h | tem_l;  
  63.         }  
  64.         *blen = (tem_len/2);  
  65.     }  
  66.     else  
  67.     {  
  68.         if (tem_len == 1)  
  69.         {  
  70.             Bbuf[0] = (byte)(Cbuf[tem_len-1] & 0x0f);  
  71.             *blen = tem_len;  
  72.         }  
  73.         else  
  74.         {  
  75.             for (i=0,j=0; i<tem_len-1; i++,j++)  
  76.             {  
  77.                 tem_h = (byte)(Cbuf[i]<<4) & 0xf0 ;  
  78.                 tem_l = (byte)(Cbuf[++i] & 0x0f);  
  79.                 Bbuf[j] = tem_h | tem_l;  
  80.             }  
  81.             Bbuf[tem_len/2] = (byte)(Cbuf[tem_len-1] & 0x0f);  
  82.             *blen = (tem_len/2)+1;  
  83.         }  
  84.     }  
  85. }  
void CharToBcd(char* Cbuf, byte* Bbuf, int* blen)
{
	int i = 0;
	int j = 0;
	int tem_len = 0;
	byte tem_h = 0;
	byte tem_l = 0;

	tem_len = (int)strlen(Cbuf);

	for (i=0; i<tem_len; i++)
	{
		switch (Cbuf[i])
		{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			Cbuf[i] = ((Cbuf[i] - 0x30) & 0x0f);
			break;
		case 'A':
		case 'a':
			Cbuf[i] = 0x0A;
			break;
		case 'B':
		case 'b':
			Cbuf[i] = 0x0B;
			break;
		case 'C':
		case 'c':
			Cbuf[i] = 0x0C;
			break;
		case 'D':
		case 'd':
			Cbuf[i] = 0x0D;
			break;
		case 'E':
		case 'e':
			Cbuf[i] = 0x0E;
			break;
		case 'F':
		case 'f':
			Cbuf[i] = 0x0F;
			break;
		default:
			break;
		}
	}

	if ((tem_len % 2) == 0)
	{
		for (i=0,j=0; i<tem_len; i++,j++)
		{
			tem_h = (byte)(Cbuf[i]<<4) & 0xf0;
			tem_l = (byte)(Cbuf[++i] & 0x0f);
			Bbuf[j] = tem_h | tem_l;
		}
		*blen = (tem_len/2);
	}
	else
	{
		if (tem_len == 1)
		{
			Bbuf[0] = (byte)(Cbuf[tem_len-1] & 0x0f);
			*blen = tem_len;
		}
		else
		{
			for (i=0,j=0; i<tem_len-1; i++,j++)
			{
				tem_h = (byte)(Cbuf[i]<<4) & 0xf0 ;
				tem_l = (byte)(Cbuf[++i] & 0x0f);
				Bbuf[j] = tem_h | tem_l;
			}
			Bbuf[tem_len/2] = (byte)(Cbuf[tem_len-1] & 0x0f);
			*blen = (tem_len/2)+1;
		}
	}
}


//=================================================

是一种用二进制编码的十进制数,又称二一十进制数。它
是用4位二进制效表示一个十进制数码的,由于这4位二进制数的权为8421,所以跃9
码又称8421码。
如1234的BCD码是:0001,0010,0011,0100



评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值