std::string,std::wstring,CString,char,char*,char数组,wchar_t*,wchar_t,wchat_t数组

wchar_t*,wchar_t,wchat_t数组,char,char*,char数组,std::string,std::wstring,CString….

 

一些转换函数，主要针对宽字符。字符串是根本啊，要好好掌握了

 

 

#include <string>

// 使用CString必须使用MFC，并且不可包含<windows.h>

#define _AFXDLL

#include <afx.h>

using namespace std;

//———————————————————————————-

//将 单字节char* 转换为 宽字节 wchar*

inline wchar_t* AnsiToUnicode( const char* szStr )

{

int nLen = MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szStr, -1, NULL, 0 );

if (nLen == 0)

{

   return NULL;

}

wchar_t* pResult = new wchar_t[nLen];

MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szStr, -1, pResult, nLen );

return pResult;

}

//———————————————————————————-

// 将 宽字节wchar_t* 转换 单字节char*

inline char* UnicodeToAnsi( const wchar_t* szStr )

{

int nLen = WideCharToMultiByte( CP_ACP, 0, szStr, -1, NULL, 0, NULL, NULL );

if (nLen == 0)

{

   return NULL;

}

char* pResult = new char[nLen];

WideCharToMultiByte( CP_ACP, 0, szStr, -1, pResult, nLen, NULL, NULL );

return pResult;

}

//———————————————————————————-

// 将单字符 string 转换为宽字符 wstring

inline void Ascii2WideString( const std::string& szStr, std::wstring& wszStr )

{

int nLength = MultiByteToWideChar( CP_ACP, 0, szStr.c_str(), -1, NULL, NULL );

wszStr.resize(nLength);

LPWSTR lpwszStr = new wchar_t[nLength];

MultiByteToWideChar( CP_ACP, 0, szStr.c_str(), -1, lpwszStr, nLength );

wszStr = lpwszStr;

delete [] lpwszStr;

}

//———————————————————————————-

int _tmain(int argc, _TCHAR* argv[])

{

char*   pChar = “我喜欢char”;

wchar_t* pWideChar = L”我讨厌wchar_t”;

wchar_t   tagWideCharList[100] ;

char   ch = ‘A’;

char   tagChar[100] = {NULL};

CString   cStr;

std::string str;

 

// 注：设置语言环境以便输出WideChar

setlocale(LC_ALL,”chs”);

 

// 注： char* 转换 wchar_t*

// 注： wchar_t 未重载 << ，所以不可使用 cout << 输出

pWideChar = AnsiToUnicode( pChar );

// 注：printf(”%ls”) 和 wprintf(L”%s”) 一致

printf( “%ls/n”, pWideChar );

 

// 注：wchar_t* 转换 wchar_t[]

wcscpy ( tagWideCharList, pWideChar );

wprintf( L”%s/n”, tagWideCharList );

 

// 注：wchar_t[] 转换 wchar_t*

pWideChar = tagWideCharList;

wprintf( L”%s/n”, pWideChar );

 

// 注：char 转换 string

str.insert( str.begin(), ch );

cout << str << endl;

 

// 注：wchar_t* 转换 string

pWideChar = new wchar_t[str.length()];

swprintf( pWideChar, L”%s”, str.c_str());

wprintf( L”%s/n”, pWideChar );

 

// 注：string 转换 char*

pChar = const_cast<char*>(str.c_str());

cout << pChar << endl;

 

// 注：char* 转换 string

str = std::string(pChar);

// 注： cout 的 << 重载了string, 若printf 的话必须 printf(”%s”, str.c_str());

//   而不可 print( “%s”, str ); 因为 str 是个 string 类

cout << str << endl;

 

// 注：string 转换 char[]

str = “无聊啊无聊”;

strcpy( tagChar, str.c_str() );

printf( “%s/n”, tagChar );

 

// 注：string 转换 CString;

cStr = str.c_str();

 

// 注：CString 转换 string

str = string(cStr.GetBuffer(cStr.GetLength()));

 

// 注：char* 转换 CString

cStr = pChar;

 

// 注：CString 转换 char*

pChar = cStr.GetBuffer( cStr.GetLength() );

 

// 注：CString 转换 char[]

strncpy( tagChar, (LPCTSTR)CString, sizeof(tagChar));

 

// 注：CString 转换 wchar_t*

pWideChar = cStr.AllocSysString();

printf( “%ls/n”, pWideChar );

}

 

转自：http://blog.shuwo.org/archives/321

 

 

一，VC中字符串类型的互相转换

总是觉得VC中的类型纷繁复杂，扑朔迷离。因为有了Unicode，因为C、C++类型相互转化如此不同。保存char的不止char一种，还可以用short

 

，unsigned short，int 等来保存。单单就字符串就有N多种类型，其它类型也不止一个。再加上C++中本来就没有正式的string类型，所以，

 

平常就会碰到很多种相同意思，但不同类型，或相同类型，不同写法的Type.

如何在他们之间相互转化，也是在学习VC中避免不了的一个问题。

 

现来看平时常用的保存字符串的类型有那些？

Cstring、TCHAR*、 TCHAR[]、 char*、 LPCSTR、 LPCTSTR、 LPBYTE

以上都是在VC中用的比较多得。他们之间如何转化：

这里，把Cstring看作一个转换的中间值，任何类型都是相它看齐。

1.      LPCSTR<-->Cstring

LPCSTR在VC中代表的是char*但并不能用char*的方式去转换它。它与Cstring可以直接互换，就像以下代码这样：

Cstring strHello;

strHello=”Hello world”;

LPCSTR lpStr=(LPCSTR)strHello;

Cstring str2;

str2=(CString)lpStr;

 

 

另外，Cstring类有一成员函数Format，可以用来把类型转换成Cstring类型，以上lpStr转换成Cstring可以这样表示：

 str2.Format(“%s”,lpStr);

 

 

2.      LPCTSTR<-->Cstring

LPCTSTR和LPCSTR转换方式是一样的，所不同的是两个类型本身不一样。LPCTSTR表示的是unsigned short*，这样，它可以支持Unicode字符类

 

型，而LPCSTR只支持ANSI字符类型。平常，我们一般可以用LPCTSTR来代替LPCSTR。

 

3.      TCHAR*(char*)<-->Cstring

TCHAR在VC中表示的是unsigned short，可以支持Unicode字符集。两类型之间的转换可以像以下这样

TCHAR* myChars = strHello.GetBuffer(strHello.GetLength());

str2=(CString)myChars; //或者str2.Format(“%s”,myChars);

 

   注意：Cstring转TCHAR*不能用以下代码转换：

myChars = (LPCTSTR)strHello; //Error,Can not Convert from ‘const char*’ to ‘char*’

 

   也不能这样转化：

 myChars=(LPTSTR)strHello; //Cstring不能转化为char*

 

但是可以这样： 

 myChars=(LPTSTR)(LPCTSTR)strHello; //先把strHello转化为const char*,再转化为char*

 

 

4.      LPBYTE<-->Cstring

LPBYTE是unsigned char*类型，它们之间的转换如下：

 LPBYTE lpByte = (LPBYTE)strHello.GetBuffer(strHello.GetLength());

 

//GetBuffer返回的是LPTSTR类型

//也可以这样转换：

 

5.      TCHAR[]<-->Cstring

它们之间的转换又不一样，因为涉及到数组。所以用strcpy函数来进行,strCpy的函数原型如下：

LPTSTR StrCpy(LPTSTR psz1,LPCTSTR )

它们之间的转换如下： 

 CHAR strChar[200]

StrCpy(strChar,(LPCTSTR)strHello);

Cstring str2 = (CString)strChar; //或者用Format函数

 

 

 

由此可见，Cstring转换到别的类型，都要转成LPCSTR或者LPCTSTR类型这一关(LPCSTR,LPCTSTR代表了const char* , const short*)。然后再

 

通过LPCSTR或LPCTSTR转换成别的类型（包括unsigned char*,char*）,所以，要把Cstring转换成其它类型，首先看这个类型是不是const 

 

char* 或者const short*，如果是，可以直接转，如果不是，首先转成LPCSTR或LPCTSTR，再把它们强制转换成相应的字符串类型.

 

              而任何类型转换成Cstring，则需要在前面加上(CString)强制转换即可，或者用Cstring类的成员函数Format

 

 

二.VC中其它常用类型转换

              其中，很多函数都用到<stdlib.h>和<wchar.h>，如果用到，要把头文件包含进源文件.

              1.字符串转换成其它类型

 

               Double atof(char* string);

 

              Double wtof(const wchar_t* string);

              int atoi(const char* string);

              _int64 _atoi64(const char* string)

 

              int wtoi(const wchar_t* string);

              int64 wtoi64(const wchar_t* string);

              long atol(const char* string);

              long wtol(const wchar_t* string);

 

 

 

              举例：

              char* s=”-2309.12E-15”;

              double x=atof(s);   //out：-2309120E-012

              s=”-9885 pigs”;

              int I=atoi(s);              //out：-9885

 

 

 

              2.其它类型转换成字符型：

               char* itoa(int value,char* string,int radix);

              char* i64toa(int64 value,char* string,int radix);

              char* ui64toa(unsigned int64 value,char* string,int radix);

              wchar_t * itow(int value, wchar_t string, int radix);

              char* _ltoa(long value,char* string,int radix);

 

 

              举例：

              int i=100;

              itoa(i,temp,10); //十进制

              itoa(i,temp,2); //二进制

 

 

 

              Cstring str;

 

              Str.Fomat(“%d”,i); //整型to Cstring

              Str.Format(“%f”,f); //Float to CString

 

转自：http://www.cnblogs.com/shipfi/archive/2006/05/16/401589.html