C++,CString,string,char*,int等转换

环境是VS2010:

string 转 CString
CString.Format(_T(”%s”), string.c_str());

int 转CString

int i = 15;

CString str;

str.Format(_T("%d"), i);

其他环境:

CString 转char *

CString cstr;
char *p = (LPSTR)(LPCTSTR)cstr;

string 转 CString

CString.format(”%s”, string.c_str());

char 转 CString
CString.format(”%s”, char*);

char 转 string
string s(char *);

string 转 char *
char *p = string.c_str();

CString 转 string
string s(CString.GetBuffer());

1，string -> CString CString.format(”%s”, string.c_str());
用c_str()确实比data()要好.
2，char -> string string s(char *);
只能初始化，在不是初始化的地方最好还是用assign().
3,CString -> string
string s(CString.GetBuffer());
GetBuffer()后一定要ReleaseBuffer(),否则就没有释放缓冲区所占的空间.
《C++标准函数库》中说的 有三个函数可以将字符串的内容转换为字符数组和C―string 1.data(),返回没有”\0“的字符串数组 2,c_str()，返回有”\0“的字符串数组 3，copy()
―――――――――――――――――――――
CString与int、char*、char[100]之间的转换- -
CString互转int 将字符转换为整数，可以使用atoi、_atoi64或atol。
而将数字转换为CString变量，可以使用CString的Format函数。
如 CString s; int i = 64; s.Format(”%d”, i) Format函数的功能很强，值得研究一下。
void CStrDlg::OnButton1() {
    // TODO: Add your control notification handler code here
    CString ss=”1212.12″;
    int temp=atoi(ss);
    CString aa;
    aa.Format(”%d”,temp);
    AfxMessageBox(”var is ” + aa);
}
    sart.Format(”%s”,buf);
    CString互转char*
    //char * TO cstring
    CString strtest;
    char * charpoint;
    charpoint=”give string a value”;
    strtest=charpoint;
    
    ///cstring TO char *
    CString 转char * CString cstr;
    char *p = (LPSTR)(LPCTSTR)cstr;
    
    string 转 CString
    CString.format(”%s”, string.c_str());
    
    char 转 CString
    CString.format(”%s”, char*);
    
    char 转 string
    string s(char *);
    
    string 转 char *
    char *p = string.c_str();
    
    
//将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位。
    中间通过判断去掉空格

//把十六进制字符串转化常规字符串
 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);