VC数据类型转换函数

 

//将ASCII码转化为16进制数
BYTE  ASCIIToHexChar(BYTE ch)
{
    if((ch>='0')&&(ch<='9'))
   {
       return ch-0x30;

   }

    else if((ch>='A')&&(ch<='F'))
    {
       return ch-'A'+10;
     }
    else if((ch>='a')&&(ch<='f'))
    {
       return ch-'a'+10;  
    }     
    else
   {
       return -1;
   }
}

 

//将char转化为16进制

char   CharToHexChar(char ch)
{
    if((ch>='0')&&(ch<='9'))
   {
       return ch-0x30;

   }

    else if((ch>='A')&&(ch<='F'))
    {
       return ch-'A'+10;
     }
    else if((ch>='a')&&(ch<='f'))
    {
       return ch-'a'+10;  
    }     
    else
   {
       return -1;
   }
}

 

//16进制字符串CString 转为 BYTE[] 数组的方法

BYTE[] StringToByteArray(CString str)

{

//CString str ="01 02 03 04";例如这样数据
 BYTE tmpByte = 0x00;
 int strLen = str.GetLength();
 BYTE cmd[1024]; //注意越界
 memset(cmd, '/0', sizeof(cmd));
 
 for (int i=0, j=0; i<sizeof(cmd),j<strLen; i++,j++)
 {
  if (str[j] == ' ')
  {
   ++j;
  }
  tmpByte = str[j];       
  cmd[i] = ASCIIToHexChar(tmpByte)<<4;//左移4位
  if (str[++j] == ' ')
  {
   ++j;
  }
  tmpByte = str[j];       
  cmd[i] = cmd[i] + (ASCIIToHexChar(tmpByte) & 0xF);//取低4位然后相加。   

}
注释：
把字符赋给BYTE，实则赋的是字符的ASCII码值，因此要先把ASCII码转化为对应的16进制数。
两个字符赋给一个BYTE，就要把第一个字符放到BYTE的高4位，而第二个字符放到BYTE的低4位。
中间通过判断去掉空格。

 

//************************************
// Method:    HexstringToString
// FullName:  HexstringToString
// Access:    public
// Returns:   返回处理后字符串 CString

// Qualifier: 把十六进制字符串转化常规字符串
//************************************
CString  HexstringToString(CString hex)
{
 CString str;
 int i,hlen,iData,iFlag;
 char ch;
 iData=0;
 iFlag=0;
 hlen=hex.GetLength();//int)strlen(hex);
 for (i=0;i<hlen;i++)
 {
  if (' '==hex[i])
  {
   continue;
  }

  ch=hex.GetAt(i);//hex[i];
  if ((ch>='0') && (ch<='9'))
  {
   ch-=0x30;
  }
  else if ((ch>='a') && (ch<='f'))
  {
   ch-=0x57;
  }
  else if ((ch>='A') && (ch<='F'))
  {
   ch-=0x37;
  }
  else
  {
           str="";
  }

  if (0==iFlag)
  {
   iData=ch;
   iFlag=1;
  }
  else
  {
   iData=(iData<<4) +ch;
   iFlag=0;
   str+=iData;
  }
 }
 return str;//0;
}

 

//************************************
//函数名称：int StrToHex(const char *str, char *hex, UINT nLength)
//功        能：将字符串（不一定是以'/0'结尾的）转化为十六进制表示的字符串,

//如："HELLO"-->"48 45 4C 4C 4F" nLength可以指定为字符串的实际长度
          
//参数说明：str--------需要转换的字符串
//               hex -------转换后的字符串
//               nLength----需要转换的字符串的长度(对不以'/0'结束的无符号数组，需要指明长度)
//返 回 值：零，成功
//************************************
int StringToHexing(const char *str, char *hex , UINT nLength)
{
     int i;
     for (i=0;i<(int)nLength;i++)
     {

         sprintf(hex+i*3,"%02X ",str[i]&0xFF); //将字符转化为相应的十六进制表示

     }
     return 0;
}

 

//************************************
// Method:    HexstringToByteAry
// FullName:  HexstringToByteAry
// Access:    public
// Returns:   int  返回转换后字节数组长度
// Qualifier: 把字符串转化字节数组
// Parameter: CString str 源十六进制字符串
// Parameter: CByteArray & data 目标字节数组
//************************************
int CTestComPortDlg::HexstringToByteAry(CString str,CByteArray &data)
{
 int t,t1;
 int rlen=0,
  len=str.GetLength();
 data.SetSize(len/2);
 for(int i=0;i<len;)
 {
  char l,h=str[i];
  if(h==' ')
  {
   i++;
   continue;
  }
  i++;
  if(i>=len)
  {
   break;
  }
  
  l=str[i];
  t=HexToChar(h);
  t1=HexToChar(l);
  if((t==16)||(t1==16))
  {
   break;
  }
  else
  {
   t=t*16+t1;
  }
  i++;
  data[rlen]=(char)t;
  rlen++;
 }
 data.SetSize(rlen);
 return rlen;
}

 

//************************************

//函数：WCharToChar
//功能：将16位wchar_t转换为 8位char[2]
//参数：wcn为待转换的16位字符，ccn[]为转换后的8位字符
//备注：wchar_t的高位字节应该存储在char数组的低位字节

//************************************
void  WCharToChar(wchar_t wcn , char ccn[])
{   
    ccn[0] = wcn >> 8 ;
    ccn[1] = (char)wcn ;
}

//************************************
//函数：WCharToHexstring
//功能：将16位字符串转换为十六进制字符串
//参数：待转换的字符串，字符串长度
//返回值：转换后的字符串
//************************************

CString  WCharToHexstring(CString data, long nDataLength)
{
 CString sResult("");
 for (long j=0; j<nDataLength;j++)
 {
  wchar_t ch = data.GetAt(j);
 
  char ccn[2]={'0'}; //将wchar_t转换为char[2]
  W2C(ch,ccn);
  
  static const char *hex = "0123456789ABCDEF";
  for(int i=0;i<2;i++)
  {
   unsigned char chHexA = hex[((unsigned char)(ccn[i]) >> 4) & 0x0f];
   unsigned char chHexB = hex[(unsigned char)(ccn[i]) & 0x0f];
   sResult += (char)chHexA;
   sResult += (char)chHexB;
  }
 }
 return sResult;
}

 

//************************************
//函数：HexstringToInt

//功能：将16位字符串转换为整形

//参数：待转换的字符串

//返回值：转换后的数据

//************************************
int  HexstringToInt(char *pstr)  
{  
 int length = strlen(pstr);  
 char ex;  
 int result=0;  
 int i = 0;  
 while(length--)  
 {  
  if (pstr[length]<='9'&&pstr[length]>='0')  

 {
   ex = pstr[length]-'0';  
 }
  else if(pstr[length]<='f'&&pstr[length]>='a') 
 { 
   ex = pstr[length]-'a'+10;  
 }
  result += ex*(int)pow(16,i);  
  i ++;  
 }  
 ///printf("result=%d/n",result);  
 return result;  

 

} 

 

//************************************
//函数：DecimalToHex

//功能：把10进制转换成16进制字符串的函数

 

//************************************

char* DecimalToHex(short n)
{
 char* p=(char*)malloc(5);
 char* p1=p+4;
 *p1=0;
 char c=0;
 while (p1>p)
 {
  c=n%16;
  n/=16;
  if (c>=10)
  {
   c+=7;
  }
  c+=0x30;
  p1--;
  *p1=c;
 }
 return p;
}

//************************************
//函数：ByteToHex

//功能：字节转换成十六进制字符

//参数：待转换的字节, 长度

//************************************

  void ByteToHex(UINT* hex,UINT n)

  {

   static const UINT HEX[] = "0123456789ABCDEF"; 

    hex[0] = HEX[n / 16];

    hex[1] = HEX[n % 16];

 

}

 

//************************************
//函数：ByteToHex

//功能：数据块转换成十六进制字符串

//参数：将一块数据转化成16进制，存放到 buff所指的缓冲区，len为要转换的字节个数

//************************************

void blockDataToHexstring(char * input,char * buff,int len)

{

    int cur;

    for (cur = 0; cur < len; cur++)

    {

        ByteToHex(buff+ 2 * cur,input[cur]);

    }

}

 

 

//************************************
//函数：ByteArrayToHex

//功能：字符数组的ASC转化位16进制

//参数：size为要转换的字节数组长度

//备注：调用如：

char asc[]="123";
static char buf[100];
FormatToHex(buf,asc,sizeof(asc));
输出字符串--"31 32 33 00 "

//************************************
void ByteArrayToHex(char *pOut,BYTE *pIn,int size)
{
  char dl,dh;
 for(int k=0;k<size;k++)
 {
         dl=pIn[k] & 0x0F;

  pOut[3*k+1]=((dl<0xA)? dl+0x30 : dl+0x37);

  dh=(pIn[k] >> 4) & 0x0F;

  pOut[3*k]=((dh<0xA)? dh+0x30 : dh+0x37);

  pOut[3*k+2]=0x20;

 }

}

 

//************************************
//函数：FormatHexstring

//功能：格式化显示字符串

//参数：字符串起始地址input,共显示 len次,每次显示size个字符

//************************************

void FormatHexstring(char * input,int len,int size)

{

    int cur = 0;

    int rowcnt = 0;

    printf("%08dh:",rowcnt++);

    do {

        printf("0x%-3.2s",input + size * cur);

        cur++;

        if (cur % 8 == 0)

        {

            printf("/n%08dh:",rowcnt++);

        }      

    } while(cur < len);
}

 

本函数关键是用好printf的格式化输出功能。

①printf("%08xh:",row_cnt++); 中的"%08x",表示输出十六进制整数，宽度为8个字符，左填充0。

②printf("0x%-3.2s",in + size * cur)；中 "%-3.2s"表示输出字符串，宽度为3，精度为2（精度表示最多输出两个字符，多的舍去）左对齐，右填充空格。

 

把十六进制数返回 整形，浮点形

可以用

整形

int data=0;

sscanf(hexstr,"%X",&data);

 

浮点形

float data=0.0;

sscanf(hexstr,"%X",&data);