字符串 常见类型转换[转]

　　C++字符串完全指引之一 -- Win32 字符编码：CodeProject：The Complete Guide to C++ Strings, Part I CString是一个动态TCHAR数组，BSTR是一种专有格式的字符串（需要用系统提供的函数来操纵，LPCTSTR只是一个常量的TCHAR指针。
　　CString 是一个完全独立的类，动态的TCHAR数组，封装了 + 等操作符和字符串操作方法。
　　typedef OLECHAR FAR* BSTR;
　　typedef const char * LPCTSTR;
　　vc++中各种字符串的表示法
　　首先char* 是指向ANSI字符数组的指针，其中每个字符占据8位（有效数据是除掉最高位的其他7位），这里保持了与传统的C,C++的兼容。
　　LP的含义是长指针(long pointer)。LPSTR是一个指向以'\0'结尾的ANSI字符数组的指针，与char*可以互换使用，在win32中较多地使用LPSTR。
　　而LPCSTR中增加的'C'的含义是"CONSTANT"（常量），表明这种数据类型的实例不能被使用它的API函数改变，除此之外，它与LPSTR是等同的。
　　1.LP表示长指针,在win16下有长指针(LP)和短指针(P)的区别,而在win32下是没有区别的,都是32位.所以这里的LP和P是等价的.
　　2.C表示const
　　3.T是什么东西呢,我们知道TCHAR在采用Unicode方式编译时是wchar_t,在普通时编译成char.
　　为了满足程序代码国际化的需要，业界推出了Unicode标准，它提供了一种简单和一致的表达字符串的方法，所有字符中的字节都是16位的值，其数量也可以满足差不多世界上所有书面语言字符的编码需求，开发程序时使用Unicode（类型为wchar_t)是一种被鼓励的做法。
　　LPWSTR与LPCWSTR由此产生，它们的含义类似于LPSTR与LPCSTR，只是字符数据是16位的wchar_t而不是char。
　　然后为了实现两种编码的通用，提出了TCHAR的定义：
　　如果定义_UNICODE，声明如下：
　　typedef wchar_t TCHAR;
　　如果没有定义_UNICODE，则声明如下：
　　typedef char TCHAR;
　　LPTSTR和LPCTSTR中的含义就是每个字符是这样的TCHAR。
　　CString类中的字符就是被声明为TCHAR类型的，它提供了一个封装好的类供用户方便地使用。
　　LPCTSTR:
　　#ifdef _UNICODE
　　typedef const wchar_t * LPCTSTR;
　　#else
　　typedef const char * LPCTSTR;
　　#endif 先定义一些常见类型变量借以说明
　　int i = 100;
　　long l = 2001;
　　float f=300.2;
　　double d=12345.119;
　　char username[]="女侠程佩君";
　　char temp[200];
　　char *buf;
　　CString str;
　　_variant_t v1;
　　_bstr_t v2; 短整型(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的成员函数Format来转换,例如:
　　整数(int)
　　str.Format("%d",i); 
　　浮点数(float)
　　str.Format("%f",i); 
　　字符串指针(char *)等已经被CString构造函数支持的数据类型可以直接赋值
　　str = username; CComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的32位指针。
　　char *转换到BSTR可以这样: BSTR b=_com_util::ConvertStringToBSTR("数据"); //使用前需要加上头文件comutil.h
　　反之可以使用char *p=_com_util::ConvertBSTRToString(b); VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。
　　对于VARIANT变量的赋值：首先给vt成员赋值，指明数据类型，再对联合结构中相同数据类型的变量赋值，举个例子：
　　VARIANT va;
　　int a=2001;
　　va.vt=VT_I4; //指明整型数据
　　va.lVal=a; //赋值
　　对于不马上赋值的VARIANT，最好先用Void VariantInit(VARIANTARG FAR* pvarg);进行初始化,其本质是将vt设置为VT_EMPTY,下表我们列举vt与常用数据的对应关系:
　　unsigned char bVal; VT_UI1 
　　short iVal; VT_I2 
　　long lVal; VT_I4
　　float fltVal; VT_R4 
　　double dblVal; VT_R8
　　VARIANT_BOOL boolVal; VT_BOOL 
　　SCODE scode; VT_ERROR 
　　CY cyVal; VT_CY 
　　DATE date; VT_DATE 
　　BSTR bstrVal; VT_BSTR 
　　IUnknown FAR* punkVal; VT_UNKNOWN 
　　IDispatch FAR* pdispVal; VT_DISPATCH 
　　SAFEARRAY FAR* parray; VT_ARRAY|* 
　　unsigned char FAR* pbVal; VT_BYREF|VT_UI1 
　　short FAR* piVal; VT_BYREF|VT_I2 
　　long FAR* plVal; VT_BYREF|VT_I4 
　　float FAR* pfltVal; VT_BYREF|VT_R4 
　　double FAR* pdblVal; VT_BYREF|VT_R8 
　　VARIANT_BOOL FAR* pboolVal; VT_BYREF|VT_BOOL 
　　SCODE FAR* pscode; VT_BYREF|VT_ERROR 
　　CY FAR* pcyVal; VT_BYREF|VT_CY 
　　DATE FAR* pdate; VT_BYREF|VT_DATE 
　　BSTR FAR* pbstrVal; VT_BYREF|VT_BSTR 
　　IUnknown FAR* FAR* ppunkVal; VT_BYREF|VT_UNKNOWN 
　　IDispatch FAR* FAR* ppdispVal; VT_BYREF|VT_DISPATCH 
　　SAFEARRAY FAR* FAR* pparray; VT_ARRAY|* 
　　VARIANT FAR* pvarVal; VT_BYREF|VT_VARIANT 
　　void FAR* byref; VT_BYREF 
　　_variant_t是VARIANT的封装类，其赋值可以使用强制类型转换，其构造函数会自动处理这些数据类型。
　　例如：
　　long l=222;
　　ing i=100;
　　_variant_t lVal(l);
　　lVal = (long)i;
　　COleVariant的使用与_variant_t的方法基本一样，请参考如下例子：
　　COleVariant v3 = "字符串", v4 = (long)1999;
　　CString str =(BSTR)v3.pbstrVal;
　　long i = v4.lVal; 对消息的处理中我们经常需要将WPARAM或LPARAM等32位数据(DWORD)分解成两个16位数据(WORD),例如：
　　LPARAM lParam;
　　WORD loValue = LOWORD(lParam); //取低16位
　　WORD hiValue = HIWORD(lParam); //取高16位
　　对于16位的数据(WORD)我们可以用同样的方法分解成高低两个8位数据(BYTE),例如:
　　WORD wValue;
　　BYTE loValue = LOBYTE(wValue); //取低8位
　　BYTE hiValue = HIBYTE(wValue); //取高8位
　　如何将CString类型的变量赋给char*类型的变量
　　1、GetBuffer函数：
　　使用CString::GetBuffer函数。
　　char *p; 
　　CString str="hello"; 
　　p=str.GetBuffer(str.GetLength()); 
　　str.ReleaseBuffer();
　　将CString转换成char * 时
　　CString str("aaaaaaa");
　　strcpy(str.GetBuffer(10),"aa");
　　str.ReleaseBuffer();
　　当我们需要字符数组时调用GetBuffer(int n),其中n为我们需要的字符数组的长度.使用完成后一定要马上调用ReleaseBuffer();
　　还有很重要的一点就是,在能使用const char *的地方,就不要使用char *
　　2、memcpy：
　　CString mCS=_T("cxl"); 
　　char mch[20]; 
　　memcpy(mch,mCS,20); 
　　3、用LPCTSTR强制转换： 尽量不使用
　　char *ch; 
　　CString str; 
　　ch=(LPSTR)(LPCTSTR)str; 
　　CString str = "good";
　　char *tmp;
　　sprintf(tmp,"%s",(LPTSTR)(LPCTSTR)str); 
　　4、
　　CString Msg; 
　　Msg=Msg+"abc"; 
　　LPTSTR lpsz; 
　　lpsz = new TCHAR[Msg.GetLength()+1]; 
　　_tcscpy(lpsz, Msg); 
　　char * psz; 
　　strcpy(psz,lpsz); 
　　CString类向const char *转换
　　char a[100];
　　CString str("aaaaaa");
　　strncpy(a,(LPCTSTR)str,sizeof(a));
　　或者如下:
　　strncpy(a,str,sizeof(a));
　　以上两种用法都是正确地. 因为strncpy的第二个参数类型为const char *.所以编译器会自动将CString类转换成const char *.
　　CString转LPCTSTR (const char *)
　　CString cStr;
　　const char *lpctStr=(LPCTSTR)cStr;
　　LPCTSTR转CString
　　LPCTSTR lpctStr;
　　CString cStr=lpctStr;
　　将char*类型的变量赋给CString型的变量
　　可以直接赋值，如：
　　CString myString = "This is a test"; 
　　也可以利用构造函数，如：
　　CString s1("Tom");
　　将CString类型的变量赋给char []类型(字符串)的变量
　　1、sprintf()函数
　　CString str = "good"; char tmp[200] ; sprintf(tmp, "%s",(LPCSTR)str); (LPCSTR)str这种强制转换相当于(LPTSTR)(LPCTSTR)str 
　　CString类的变量需要转换为(char*)的时,使用(LPTSTR)(LPCTSTR)str 
　　然而，LPCTSTR是const char *,也就是说，得到的字符串是不可写的！将其强制转换成LPTSTR去掉const，是极为危险的！
　　一不留神就会完蛋！要得到char *,应该用GetBuffer()或GetBufferSetLength()，用完后再调用ReleaseBuffer()。
　　2、strcpy()函数
　　CString str;
　　char c[256];
　　strcpy(c, str); 
　　char mychar[1024];
　　CString source="Hello";
　　strcpy((char*)&mychar,(LPCTSTR)source);  1、指定 CString 形参
　　对于大多数需要字符串参数的函数，最好将函数原型中的形参指定为一个指向字符 (LPCTSTR) 而非 CString 的 const 指针。
　　当将形参指定为指向字符的 const 指针时，可将指针传递到 TCHAR 数组（如字符串 ["hi there"]）或传递到 CString 对象。
　　CString 对象将自动转换成 LPCTSTR。任何能够使用 LPCTSTR 的地方也能够使用 CString 对象。
　　2、如果某个形参将不会被修改，则也将该参数指定为常数字符串引用（即 const CString&）。如果函数要修改该字符串，
　　则删除 const 修饰符。如果需要默认为空值，则将其初始化为空字符串 [""]，如下所示：
　　void AddCustomer( const CString& name, const CString& address, const CString& comment = "" ); 
　　3、对于大多数函数结果，按值返回 CString 对象即可。 对于串的基本运算，很多高级语言均提供了相应的运算符或标准的库函数来实现。
　　为叙述方便，先定义几个相关的变量：
　　char s1[20]="dir/bin/appl",s2[20]="file.asm",s3[30],*p;
　　int result;
　　下面以C语言中串运算介绍串的基本运算
　　1、求串长
　　int strlen(char *s); //求串s的长度
　　【例】printf("%d",strlen(s1)); //输出s1的串长12
　　2、串复制
　　char *strcpy(char *to,*from)；//将from串复制到to串中，并返回to开始处指针
　　【例】strcpy(s3,s1); //s3="dir/bin/appl",s1串不变
　　3、联接
　　char *strcat(char *to,char *from);//将from串复制到to串的末尾，
　　//并返回to串开始处的指针
　　【例】strcat(s3,"/"); //s3="dir/bin/appl/"
　　strcat(s3,s2); //s3="dir/bin/appl/file.asm"
　　4、串比较
　　int strcmp(char *s1,char *s2);//比较s1和s2的大小，
　　//当s1s2和s1=s2时，分别返回小于0、大于0和等于0的值
　　【例】result=strcmp("baker","Baker"); //result>0
　　result=strcmp("12","12"); //result=0
　　result=strcmp("Joe","joseph") //result字符串s中第一次出现的位置，
　　//若找到，则返回该位置，否则返回NULL
　　【例】p=strchr(s2,'.'); //p指向"file"之后的位置
　　if(p) strcpy(p,".cpp"); //s2="file.cpp" 
　　注意：
　　①上述操作是最基本的，其中后 4个操作还有变种形式：strncpy，strncath和strnchr。
　　②其它的串操作见C的。在不同的高级语言中，对串运算的种类及符号都不尽相同
　　③其余的串操作一般可由这些基本操作组合而成
　　【例】求子串的操作可如下实现：
　　void substr(char *sub,char *s,int pos,int len){
　　//s和sub是字符数组，用sub返回串s的第pos个字符起长度为len的子串
　　//其中0strlen(s)-1||len字符串转换操作。本文先介绍基本字符串类型，然后说明相关的类，如CComBSTR、_bstr_t、CStringT等，最后讨论他们的转换方法，其中还包括使用最新ATL7.0的转换类和宏，如CA2CT、CA2TEX等。
　　一、BSTR、LPSTR和LPWSTR
　　在Visual C++.NET的所有编程方式中，我们常常要用到这样的一些基本字符串类型，如BSTR、LPSTR和LPWSTR等。之所以出现类似上述的这些数据类型，是因为不同编程语言之间的数据交换及对ANSI、Unicode和多字节字符集(MBCS)的支持。
　　那么什么是BSTR、LPSTR及LPWSTR呢？
　　BSTR(Basic STRing，Basic字符串)是个OLECHAR*类型的Unicode字符串。他被描述成一个和自动化相兼容的类型。由于操作系统提供相应的API函数(如SysAllocString)来管理他及一些默认的调度代码，因此BSTR实际上就是个COM字符串，但他却在自动化技术以外的多种场合下得到广泛使用。图1描述了BSTR的结构，其中DWORD值是字符串中实际所占用的字节数，且他的值是字符串中Unicode字符的两倍。
　　LPSTR和LPWSTR是Win32和VC++所使用的一种字符串数据类型。LPSTR被定义成是个指向以NULL('＼0')结尾的8位ANSI字符数组指针，而LPWSTR是个指向以NULL结尾的16位双字节字符数组指针。在VC++中，更有类似的字符串类型，如LPTSTR、LPCTSTR等，他们的含义如图2所示。
　　例如，LPCTSTR是指"long pointer to a constant generic string"，表示"一个指向一般字符串常量的长指针类型"，和C/C++的const char*相映射，而LPTSTR映射为 char*。
　　一般地，更有下列类型定义：  二、CString、CStringA 和 CStringW
　　Visual C++.NET中将CStringT作为ATL和MFC的共享的"一般"字符串类，他有CString、CStringA和CStringW三种形式，分别操作不同字符类型的字符串。这些字符类型是TCHAR、char和wchar_t。TCHAR在Unicode平台中等同于WCHAR(16位Unicode字符)，在ANSI中等价于char。wchar_t通常定义为unsigned short。由于CString在MFC应用程式中经常用到，这里不再重复。
　　三、VARIANT、COleVariant 和_variant_t
　　在OLE、ActiveX和COM中，VARIANT数据类型提供了一种非常有效的机制，由于他既包含了数据本身，也包含了数据的类型，因而他能实现各种不同的自动化数据的传输。下面让我们来看看OAIDL.H文件中VARIANT定义的一个简化版：  struct tagVARIANT { VARTYPE vt; union { short iVal; // VT_I2. long lVal; // VT_I4. float fltVal; // VT_R4. double dblVal; // VT_R8. DATE date; // VT_DATE. BSTR bstrVal; // VT_BSTR. … short * piVal; // VT_BYREF|VT_I2. long * plVal; // VT_BYREF|VT_I4. float * pfltVal; // VT_BYREF|VT_R4. double * pdblVal; // VT_BYREF|VT_R8. DATE * pdate; // VT_BYREF|VT_DATE. BSTR * pbstrVal; // VT_BYREF|VT_BSTR. }; }; 显然，VARIANT类型是个C结构，他包含了一个类型成员vt、一些保留字节及一个大的union类型。例如，如果vt为VT_I2，那么我们能从iVal中读出VARIANT的值。同样，当给一个VARIANT变量赋值时，也要先指明其类型。例如：  为了方便处理VARIANT类型的变量，视窗系统还提供了这样一些非常有用的函数：
　　VariantInit -- 将变量初始化为VT_EMPTY；
　　VariantClear -- 消除并初始化VARIANT；
　　VariantChangeType -- 改动VARIANT的类型；
　　VariantCopy -- 释放和目标VARIANT相连的内存并复制源VARIANT。
　　COleVariant类是对VARIANT结构的封装。他的构造函数具有极为强大大的功能，当对象构造时首先调用VariantInit进行初始化，然后根据参数中的标准类型调用相应的构造函数，并使用VariantCopy进行转换赋值操作，当VARIANT对象不在有效范围时，他的析构函数就会被自动调用，由于析构函数调用了VariantClear，因而相应的内存就会被自动清除。除此之外，COleVariant的赋值操作符在和VARIANT类型转换中为我们提供极大的方便。例如下面的代码：  COleVariant v1("This is a test"); // 直接构造
　　COleVariant v2 = "This is a test";
　　// 结果是VT_BSTR类型，值为"This is a test"
　　COleVariant v3((long)2002);
　　COleVariant v4 = (long)2002;
　　// 结果是VT_I4类型，值为2002 _variant_t是个用于COM的VARIANT类，他的功能和COleVariant相似。不过在Visual C++.NET的MFC应用程式中使用时需要在代码文件前面添加下列两句：  四、CComBSTR和_bstr_t
　　CComBSTR是对BSTR数据类型封装的一个ATL类，他的操作比较方便。例如：  CComBSTR bstr1; bstr1 = "Bye"; // 直接赋值
　　OLECHAR* str = OLESTR("ta ta"); // 长度为5的宽字符
　　CComBSTR bstr2(wcslen(str)); // 定义长度为5
　　wcscpy(bstr2.m_str, str); // 将宽字符串复制到BSTR中
　　CComBSTR bstr3(5, OLESTR("Hello World"));
　　CComBSTR bstr4(5, "Hello World");
　　CComBSTR bstr5(OLESTR("Hey there"));
　　CComBSTR bstr6("Hey there");
　　CComBSTR bstr7(bstr6);
　　// 构造时复制，内容为"Hey there" _bstr_t是是C++对BSTR的封装，他的构造和析构函数分别调用SysAllocString和SysFreeString函数，其他操作是借用BSTR API函数。和_variant_t相似，使用时也要添加comutil.h和comsupp.lib。
　　五、BSTR、char*和CString转换
　　(1) char*转换成CString 
　　若将char*转换成CString，除了直接赋值外，还可使用CString::Format进行。例如：  (2) CString转换成char* 
　　若将CString类转换成char*(LPSTR)类型，常常使用下列三种方法：
　　方法一，使用强制转换。例如：  方法二，使用strcpy。例如：  需要说明的是，strcpy(或可移值Unicode/MBCS的_tcscpy)的第二个参数是 const wchar_t* (Unicode)或const char* (ANSI)，系统编译器将会自动对其进行转换。
　　方法三，使用CString::GetBuffer。例如：  CString s(_T("This is a test ")); LPTSTR p = s.GetBuffer(); // 在这里添加使用p的代码
　　if(p != NULL) *p = _T('＼0');
　　s.ReleaseBuffer();
　　// 使用完后及时释放，以便能使用其他的CString成员函数 (3) BSTR转换成char* 
　　方法一，使用ConvertBSTRToString。例如：  方法二，使用_bstr_t的赋值运算符重载。例如：  (4) char*转换成BSTR 
　　方法一，使用SysAllocString等API函数。例如：  方法二，使用COleVariant或_variant_t。例如：  方法三，使用_bstr_t，这是一种最简单的方法。例如：  方法四，使用CComBSTR。例如：  方法五，使用ConvertStringToBSTR。例如：  (5) CString转换成BSTR 
　　通常是通过使用CStringT::AllocSysString来实现。例如：  (6) BSTR转换成CString 
　　一般可按下列方法进行：  (7) ANSI、Unicode和宽字符之间的转换
　　方法一，使用MultiByteToWideChar将ANSI字符转换成Unicode字符，使用WideCharToMultiByte将Unicode字符转换成ANSI字符。
　　方法二，使用"_T"将ANSI转换成"一般"类型字符串，使用"L"将ANSI转换成Unicode，而在托管C++环境中还可使用S将ANSI字符串转换成String*对象。例如：  方法三，使用ATL 7.0的转换宏和类。ATL7.0在原有3.0基础上完善和增加了许多字符串转换宏及提供相应的类，他具有如图3所示的统一形式：
　　其中，第一个C表示"类"，以便于ATL 3.0宏相差别，第二个C表示常量，2表示"to"，EX表示要开辟一定大小的缓冲。SourceType和DestinationType能是A、T、W和OLE，其含义分别是ANSI、Unicode、"一般"类型和OLE字符串。例如，CA2CT就是将ANSI转换成一般类型的字符串常量。下面是一些示例代码：  六、结语
　　几乎所有的程式都要用到字符串，而Visual C++.NET由于功能强大、应用广泛，因而字符串之间的转换更为频繁。本文几乎涉及到目前的所有转换方法。当然对于.NET框架来说，还可使用Convert和Text类进行不同数据类型及字符编码之间的相互转换。