VC数据类型使用转换

来源：互联网发布：linux内核编程视频编辑：程序博客网时间：2024/05/05 18:50

atof(将字符串转换成浮点型数)
atoi(将字符串转换成整型数)
atol(将字符串转换成长整型数)
strtod(将字符串转换成浮点数)
strtol(将字符串转换成长整型数)
strtoul(将字符串转换成无符号长整型数)
toascii(将整型数转换成合法的ASCII 码字符)
toupper(将小写字母转换成大写字母)
tolower(将大写字母转换成小写字母)

     atof(将字符串转换成浮点型数)
相关函数 atoi,atol,strtod,strtol,strtoul
表头文件 #include <stdlib.h>
定义函数 double atof(const char *nptr);
函数说明 atof()会扫描参数nptr字符串,跳过前面的空格字符,直到遇上数
     字或正负符号才开始做转换,而再遇到非数字或字符串结束时
     ('\0')才结束转换,并将结果返回。参数nptr字符串可包含正负
     号、小数点或E(e)来表示指数部分,如123.456或123e-2。
返回值返回转换后的浮点型数。
附加说明 atof()与使用strtod(nptr,(char**)NULL)结果相同。
范例 /* 将字符串a 与字符串b转换成数字后相加*/
     #include<stdlib.h>
     main()
     {
     char *a=”-100.23”;
     char *b=”200e-2”;
     float c;
     c=atof(a)+atof(b);
     printf(“c=%.2f\n”,c);
     }
执行 c=-98.23
     atoi(将字符串转换成整型数)
相关函数 atof,atol,atrtod,strtol,strtoul
表头文件 #include<stdlib.h>
定义函数 int atoi(const char *nptr);
函数说明 atoi()会扫描参数nptr字符串,跳过前面的空格字符,直到遇上数
     字或正负符号才开始做转换,而再遇到非数字或字符串结束时
     ('\0')才结束转换,并将结果返回。
返回值返回转换后的整型数。
附加说明 atoi()与使用strtol(nptr,(char**)NULL,10);结果相同。
范例 /* 将字符串a 与字符串b转换成数字后相加*/
     #include<stdlib.h>
     mian()
     {
     char a[]=”-100”;
     char b[]=”456”;
     int c;
     c=atoi(a)+atoi(b);
     printf(c=%d\n”,c);
     }
执行 c=356
     atol(将字符串转换成长整型数)
相关函数 atof,atoi,strtod,strtol,strtoul
表头文件 #include<stdlib.h>
定义函数 long atol(const char *nptr);
函数说明 atol()会扫描参数nptr字符串,跳过前面的空格字符,直到遇上数
     字或正负符号才开始做转换,而再遇到非数字或字符串结束时
     ('\0')才结束转换,并将结果返回。
返回值返回转换后的长整型数。
附加说明 atol()与使用strtol(nptr,(char**)NULL,10);结果相同。
范例 /*将字符串a与字符串b转换成数字后相加*/
     #include<stdlib.h>
     main()
     {
     char a[]=”1000000000”;
     char b[]=” 234567890”;
     long c;
     c=atol(a)+atol(b);
     printf(“c=%d\n”,c);
     }
执行 c=1234567890
     gcvt(将浮点型数转换为字符串,取四舍五入)
相关函数 ecvt,fcvt,sprintf
表头文件 #include<stdlib.h>
定义函数 char *gcvt(double number,size_t ndigits,char *buf);
函数说明 gcvt()用来将参数number转换成ASCII码字符串,参数ndigits表示
     显示的位数。gcvt()与ecvt()和fcvt()不同的地方在于,gcvt()所
     转换后的字符串包含小数点或正负符号。若转换成功,转换后的字
     符串会放在参数buf指针所指的空间。
返回值返回一字符串指针,此地址即为buf指针。
附加说明
范例 #include<stdlib.h>
     main()
     {
     double a=123.45;
     double b=-1234.56;
     char *ptr;
     int decpt,sign;
     gcvt(a,5,ptr);
     printf(“a value=%s\n”,ptr);
     ptr=gcvt(b,6,ptr);
     printf(“b value=%s\n”,ptr);
     }
执行 a value=123.45
     b value=-1234.56
     strtod(将字符串转换成浮点数)
相关函数 atoi,atol,strtod,strtol,strtoul
表头文件 #include<stdlib.h>
定义函数 double strtod(const char *nptr,char **endptr);
函数说明 strtod()会扫描参数nptr字符串,跳过前面的空格字符,直到遇上
     数字或正负符号才开始做转换,到出现非数字或字符串结束时
     ('\0')才结束转换,并将结果返回。若endptr不为NULL,则会将遇
     到不合条件而终止的nptr中的字符指针由endptr传回。参数nptr字
     符串可包含正负号、小数点或E(e)来表示指数部分。如123.456或
     123e-2。
返回值返回转换后的浮点型数。
附加说明参考atof()。
范例 /*将字符串a,b,c 分别采用10,2,16 进制转换成数字*/
     #include<stdlib.h>
     mian()
     {
     char a[]=”1000000000”;
     char b[]=”1000000000”;
     char c[]=”ffff”;
     printf(“a=%d\n”,strtod(a,NULL,10));
     printf(“b=%d\n”,strtod(b,NULL,2));
     printf(“c=%d\n”,strtod(c,NULL,16));
     }
执行 a=1000000000
     b=512
     c=65535
     strtol(将字符串转换成长整型数)
相关函数 atof,atoi,atol,strtod,strtoul
表头文件 #include<stdlib.h>
定义函数 long int strtol(const char *nptr,char **endptr,int base);
函数说明 strtol()会将参数nptr字符串根据参数base来转换成长整型数。参
     数base范围从2至36,或0。参数base代表采用的进制方式,如base
     值为10则采用10进制,若base值为16则采用16进制等。当base值为0
     时则是采用10进制做转换,但遇到如'0x'前置字符则会使用16进制
     做转换。一开始strtol()会扫描参数nptr字符串,跳过前面的空格
     字符,直到遇上数字或正负符号才开始做转换,再遇到非数字或字
     符串结束时('\0')结束转换,并将结果返回。若参数endptr不为
     NULL,则会将遇到不合条件而终止的nptr中的字符指针由endptr返
     回。
返回值返回转换后的长整型数,否则返回ERANGE并将错误代码存入errno
     中。
附加说明 ERANGE指定的转换字符串超出合法范围。
范例 /* 将字符串a,b,c 分别采用10,2,16进制转换成数字*/
     #include<stdlib.h>
     main()
     {
     char a[]=”1000000000”;
     char b[]=”1000000000”;
     char c[]=”ffff”;
     printf(“a=%d\n”,strtol(a,NULL,10));
     printf(“b=%d\n”,strtol(b,NULL,2));
     printf(“c=%d\n”,strtol(c,NULL,16));
     }
执行 a=1000000000
     b=512
     c=65535
     strtoul(将字符串转换成无符号长整型数)
相关函数 atof,atoi,atol,strtod,strtol
表头文件 #include<stdlib.h>
定义函数 unsigned long int strtoul(const char *nptr,char
     **endptr,int base);

函数说明 strtoul()会将参数nptr字符串根据参数base来转换成无符号的长整
     型数。参数base范围从2至36,或0。参数base代表采用的进制方
     式,如base值为10则采用10进制,若base值为16则采用16进制数
     等。当base值为0时则是采用10进制做转换,但遇到如'0x'前置字符
     则会使用16进制做转换。一开始strtoul()会扫描参数nptr字符串,
     跳过前面的空格字符串,直到遇上数字或正负符号才开始做转换,
     再遇到非数字或字符串结束时('\0')结束转换,并将结果返回。若
     参数endptr不为NULL,则会将遇到不合条件而终止的nptr中的字符
     指针由endptr返回。
返回值返回转换后的长整型数,否则返回ERANGE并将错误代码存入errno
     中。
附加说明 ERANGE指定的转换字符串超出合法范围。
范例参考strtol()
     toascii(将整型数转换成合法的ASCII 码字符)
相关函数 isascii,toupper,tolower
表头文件 #include<ctype.h>
定义函数 int toascii(int c)
函数说明 toascii()会将参数c转换成7位的unsigned char值,第八位则会被
     清除,此字符即会被转成ASCII码字符。
返回值将转换成功的ASCII码字符值返回。
范例 #include<stdlib.h>
     main()
     {
     int a=217;
     char b;
     printf(“before toascii () : a value =%d(%c)\n”,a,a);
     b=toascii(a);
     printf(“after toascii() : a value =%d(%c)\n”,b,b);
     }
执行 before toascii() : a value =217()
     after toascii() : a value =89(Y)
     tolower(将大写字母转换成小写字母)
相关函数 isalpha,toupper
表头文件 #include<stdlib.h>
定义函数 int tolower(int c);
函数说明若参数c为大写字母则将该对应的小写字母返回。
返回值返回转换后的小写字母,若不须转换则将参数c值返回。
附加说明
范例 /* 将s字符串内的大写字母转换成小写字母*/
     #include<ctype.h>
     main()
     {
     char s[]=”aBcDeFgH12345;!#$”;
     int i;
     printf(“before tolower() : %s\n”,s);
     for(i=0;I<sizeof(s);i++)
     s[i]=tolower(s[i]);
     printf(“after tolower() : %s\n”,s);
     }
执行 before tolower() : aBcDeFgH12345;!#$
     after tolower() : abcdefgh12345;!#$
     toupper(将小写字母转换成大写字母)
相关函数 isalpha,tolower
表头文件 #include<ctype.h>
定义函数 int toupper(int c);
函数说明若参数c为小写字母则将该对映的大写字母返回。
返回值返回转换后的大写字母,若不须转换则将参数c值返回。
附加说明
范例 /* 将s字符串内的小写字母转换成大写字母*/
     #include<ctype.h>
     main()
     {
     char s[]=”aBcDeFgH12345;!#$”;
     int i;
     printf(“before toupper() : %s\n”,s);
     for(i=0;I<sizeof(s);i++)
     s[i]=toupper(s[i]);
     printf(“after toupper() : %s\n”,s);
     }
执行 before toupper() : aBcDeFgH12345;!#$
     after toupper() : ABCDEFGH12345;!#$

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

float ----->string;

char ch3[10]；

sprintf(ch3,"%f",11.3333333333);

//将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);

(1) char*转换成CString
　　若将char*转换成CString，除了直接赋值外，还可使用CString::Format进行。例如：
         char chArray[] = "Char test";
         TCHAR * p = _T("Char test");( 或LPTSTR p = _T("Char test");)
         CString theString = chArray;
         theString.Format(_T("%s"), chArray);
         theString = p;

(2) CString转换成char*

　　若将CString类转换成char*(LPSTR)类型，常常使用下列三种方法：

　　方法一，使用强制转换。例如：

CString theString( (_T("Char test "));
LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString;

　　方法二，使用strcpy。例如：

       CString theString( (_T("Char test "));
       LPTSTR lpsz = new TCHAR[theString.GetLength()+1];
        _tcscpy(lpsz, theString);

　　需要说明的是，strcpy(或可移值的_tcscpy)的第二个参数是 const wchar_t* (Unicode)或const char*
(ANSI)，系统编译器将会自动对其进行转换。

　　方法三，使用CString::GetBuffer。
        如果你需要修改 CString 中的内容，它有一个特殊的方法可以使用，那就是 GetBuffer，它的作用是返回一个可写的缓冲指针。
如果你只是打算修改字符或者截短字符串，例如：
       CString s(_T("Char test "));
        LPTSTR p = s.GetBuffer();
        LPTSTR dot = strchr(p, ''.'');
         // 在这里添加使用p的代码
          if(p != NULL)
         *p = _T('/0');
         s.ReleaseBuffer();                     // 使用完后及时释放，以便能使用其它的CString成员函数
         在 GetBuffer 和 ReleaseBuffer 之间这个范围，一定不能使用你要操作的这个缓冲的 CString 对象的任何方法。因为
ReleaseBuffer 被调用之前，该 CString 对象的完整性得不到保障。

常规转换

先定义一些常见类型变量借以说明
                              int i = 100;
                              long l = 2001;
                              float f=300.2;
                              double d=12345.119;
                              char username[]="xx";
                              char temp[200];
                              char *buf;
                              CString str;

                 一、其它数据类型转换为字符串
                              短整型(int)
                                     itoa(i,temp,10);   /将i转换为字符串放入temp中,最后一个数字表示十进制
                                     itoa(i,temp,2);      //按二进制方式转换

长整型(long)
ltoa(l,temp,10);

                 二、从其它包含字符串的变量中获取指向该字符串的指针
                              CString变量
                              str = "2008北京奥运";
                              buf = (LPSTR)(LPCTSTR)str;

                              BSTR类型的_variant_t变量
                              v1 = (_bstr_t)"程序员";
                              buf = _com_util::ConvertBSTRToString((_bstr_t)v1);

三、字符串转换为其它数据类型
strcpy(temp,"123");

短整型(int)
i = atoi(temp);

长整型(long)
l = atol(temp);

浮点(double)
d = atof(temp);

四、其它数据类型转换到CString
使用CString的成员函数Format来转换,例如:

整数(int)
str.Format("%d",i);

浮点数(float)
str.Format("%f",i);

字符串指针(char *)等已经被CString构造函数支持的数据类型可以直接赋值
str = username;

五、BSTR、_bstr_t与CComBSTR
CComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的32位指针。

                              char *转换到BSTR可以这样: BSTR
                              b=_com_util::ConvertStringToBSTR("数据");
                              //使用前需要加上头文件comutil.h

反之可以使用char *p=_com_util::ConvertBSTRToString(b);

六、variant转化为CString

VariantToString(_variant_t varValue)
{
   if(varValue.vt!=VT_BSTR)
   {
     varValue.ChangeType(VT_BSTR);
   }

return (char*)_bstr_t(varValue.bstrVal);
}

注意：加上头文件 #include "comdef.h"

Variant 转化为Long方法

VariantToLong(const VARIANT &var)
{
long r;
switch(var.vt)
{
case VT_UI2://USHORT
  r = var.uiVal;
  break;
case VT_UI4://ULONG
  r = var.ulVal;
  break;
case VT_INT://INT
  r = var.intVal;
  break;
case VT_UINT://UINT
  r = var.uintVal;
  break;
case VT_I4://LONG
  r = var.lVal;
  break;
case VT_UI1://BYTE
  r = var.bVal;
  break;
case VT_I2://SHORT
  r = var.iVal;
  break;
case VT_R4://FLOAT
  r = (long)var.fltVal;
  break;
case VT_R8://DOUBLE
  r = (long)var.dblVal;
  break;
default:
  r = -1;//无法转换该值
  break;
}
return r;
}

参考来源：http://blog.csdn.net/cgli1/article/details/5470396