CString与LPCWSTR、LPSTR、char*、LPWSTR等类型的转换
_T的意思是通知编译器，自行进行字符串的多字节/Unicode转换。 而L表示，该字符串为Unicode版本。http://www.blogjava.net/neumqp/archive/2006/03/09/34504.html
http://blog.csdn.net/sl159/article/details/6412171
http://www.cnblogs.com/fire-phoenix/archive/2010/09/04/1818248.html
先区别一下字符数组和字符指针变量
（1）字符数组是由若干个元素组成的，每个元素中放了一个字符，而字符指针变量中存放的是地址（字符串第一个字符的地址），绝不是将字符串存放到字符指针变量中
（2）赋值方式。对字符数组只能对各个元素赋值，不能用以下办法对字符数组赋值：
char str[14];
str="I love you";
而对字符指针变量，可以采用下面方法赋值：
char* a;
a="I love you";
但是，注意赋给a的不是字符，而是字符串第一个元素的地址。
（3）对字符指针变量赋初值
char * a="I love you";
等价于
char* a;
a="I love you";
而对数组的初始化：char str[14]={"I love you"};
不能等价于
char str[14];
str[]="I love you";
即数组可以在定义时整体赋初值，但不能在赋值语句中整体赋值。
（4）如果定义了一个字符数组，在编译时已经为它分配了内存单元，它有确定的地址。而定义一个字符指针变量时，在没有给其赋值的前提下，它并没有一个确定的地址；只有赋值字符串后，才确定了地址，才可以指向一个字符串。可以如下方式
char *a, str[10];
a=str;
然后，就可以用字符指针变量的下标形式引用字符了。
还有一点，特别注意，字符数组名虽然代表地址，它他是常量，它的值值不能改变的。下面是错误的
char str[]={"I love you"};
str=str+7;
printf("%s",str);
而指针变量的值是可以改变的，指向的是地址。下面是正确的：
char* a="I love you";
a=a+7;
printf("%s",a);//结果为 you
========================================================================
char*,const char*和string的相互转换
1. string转const char*
2. const char*转string
3. string转char*
4. char*转string
5. const char*转char*
6. char*转const char*
extern "C" char* hello(char* name)
{
CString names="";
names.Format("%s",name);
CString cs="Hello JNA world, ";
cs+=names;
//错误，
//char* re=cs.GetBuffer(cs.GetLength());
//正确，需要复制
int len = cs.GetLength();
char* c=new char[len+1];
strcpy(c,cs.GetBuffer(len));
return c;
//AfxMessageBox(cs);
}
//char 数组相连
char*b="bc";
char*c="ef";
char* p=new char(27);
memset(p,0,27);//设置初值
strcpy(p,b);
strcat(p,c);
CString cs;
cs.Format("%s",p);
CString len;
len.Format("%d",cs.GetLength()); //注意此时的长度，并不是先前定义的27，与memset设置初值有关。请测试。
MessageBox(cs+"长度为"+len);
//另外，将char型连接到char*的后面
char*b="bc";
char*c="ef";
char* p=new char(27);
memset(p,0,27);//先赋初值后，在通过下标引用。否则p中的内容会出现乱码形式。
strcpy(p,b);
strcat(p,c);
char a='a';
p[strlen(p)]=a;//重点。
main()
{
char str1[10]="world!";
char str2[20]="hello ";
strcpy(str2+strlen(str2),str1);
printf("%s",str2);
}
//==================没有上个简单
char gray[] = "Gray";
char cat[] = "Cat";
char * graycat =(char*) malloc(strlen(gray) + strlen(cat) + 1);
strcpy(graycat, gray);
strcat(graycat, cat);
//==================
CString 和string
CString->std::string 例子：
CString strMfc=“test“;
std::string strStl;
strStl=strMfc.GetBuffer(0);
strMfc.ReleaseBuffer();//要释放
std::string->CString 例子：
CString strMfc;
std::string strStl=“test“;
strMfc=strStl.c_str();
CString和char*在第四部分
=======================================================================================
BSTR, _bstr_t, CComBSTR, CString
http://blog.csdn.net/chenwanming507507507/article/details/5884401
这里总结了BSTR, _bstr_t, CComBSTR, CString四种字符串类型之间的转换。其中BSTR为基本数据类型，另三个为字符串类。
首先声明四个类型的变量：
BSTR strBigBSTR = ::SysAllocString( _T( "BSTR" ));
_bstr_t strSmallBSTR( _T( “_bstr_t” )) ;
CComBSTR strCComBSTR( _T( “CComBSTR” ))
CString strCString( _T( “CString” ));
CComBSTR strTempCComBSTR( _T( “TempCComBSTR” ));
1． BSTR to Other Type
BSTR转换为其他类型非常方便，直接使用类的构造函数即可
// BSTR to _bstr_t
strSmallBSTR = _bstr_t( strBigBSTR );
// BSTR to CComBSTR
strCComBSTR = CComBSTR( strBigBSTR );
// BSTR to CString
strCString = CString( strBigBSTR );
2． _bstr_t to Other Type
基本思想是先把_bstr_t转化为TCHAR*, 再转化为其他类型。
// _bstr_t to BSTR
strTempCComBSTR = CComBSTR( static_cast<TCHAR*>( strSmallBSTR ));
strBigBSTR = strTempCComBSTR.m_str;
// _bstr_t to CComBSTR
strCComBSTR = CComBSTR( static_cast<TCHAR*>( strSmallBSTR ));
// _bstr_t to CString
strCString = CString( static_cast<TCHAR*>( strSmallBSTR ));
_bstr_t类重载了操作符char*和wchar_t*（TCHAR*的两种形式），所以这里并不是使用强制转换，而是调用了_bstr_t的函数。
3． CComBSTR to Other Type
基本思想是使用CComBSTR的公有成员变量m_str进行转换。
// CComBSTR to BSTR
strBigBSTR = strCComBSTR.m_str;
// CComBSTR to _bstr_t
strSmallBSTR = _bstr_t( strCComBSTR.m_str );
// CComBSTR to CString
strCString = CString( strCComBSTR.m_str );
4． CString to Other Type
基本思想是先把CString转化为LPCTSTR, 再转化为其他类型。
// CString to BSTR
strTempCComBSTR = CComBSTR( static_cast<LPCTSTR>( strCString ));
strBigBSTR = strTempCComBSTR.m_str;
// CString to _bstr_t
strSmallBSTR = _bstr_t( static_cast<LPCTSTR>( strCString ));
// CString to CComBSTR
strCComBSTR = CComBSTR( static_cast<LPCTSTR>( strCString ));
CString类重载了操作符LPCTSTR，所以这里并不是使用强制转换，而是调用了CString的函数。
5． 注意事项：
其他类型转化为BSTR类型时都使用的CComBSTR作为中转，因为这样不需要自己释放内存。但是要注意的是，转换后BSTR指向的是CComBSTR的内存，所以一旦CComBSTR被销毁了，BSTR也就失效了，这样会导致不可预知的错误。所以一定要保证CComBSTR大于或等于BSTR的周期。
下面用法是错误的：
strBigBSTR = CComBSTR(( LPCTSTR )strCString ).m_str;
因为CComBSTR在此条语句结束后就被析构了。
===============================================
VC里一般都提供CString的接口
LPTSTR
LPCSTR
所以直接使用就是了。
LPTSTR lptstr = (LPTSTR)temp;
LPCTSTR lpctstr = (LPCTSTR)temp;
string wstring _bstr_t的互相转换
string ansi字符串
wstring unicode字符串
_bstr_t com字符串
之间的转换关系，示例如下：
// ex_02_wstring_cv_string.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "string"
#include "icrsint.h"
#include "comutil.h"
using namespace std;
#import "C:\\Program Files\\Common Files\\System\\ADO\\msado15.dll" no_namespace rename("EOF", "EndOfFile")
int _tmain(int argc, _TCHAR* argv[])
{
CoInitialize(NULL);
wstring ws1,ws2;
ws2 = L"春如旧，人空瘦，泪痕红浥鲛绡透。桃花落，闲池阁，山盟虽在，锦书难托。莫、莫、莫。";
// 从 unicode 字符串转化为 ansi字符串
string s = (char *) _bstr_t ( ws2.c_str() );
// 从 ansi字符串转化为 unicode 字符串
ws1 = ( wchar_t *) ( _bstr_t ( s.c_str( ) ));
setlocale(LC_ALL, "chs");
wprintf( L"原wstring串=%s\n",ws2.c_str());
printf( "转换为string串=%s\n", s.c_str());
wprintf( L"转换为wstring串=%s\n",ws1.c_str());
::CoUninitialize();
getchar();
return 0;
}
--- 结果 ---
原wstring串=春如旧，人空瘦，泪痕红浥鲛绡透。桃花落，闲池阁，山盟虽在，锦书难托。莫、莫、莫。
转换为string串=春如旧，人空瘦，泪痕红浥鲛绡透。桃花落，闲池阁，山盟虽在，锦书难托。莫、莫、莫。
转换为wstring串=春如旧，人空瘦，泪痕红浥鲛绡透。桃花落，闲池阁，山盟虽在，锦书难托。莫、莫、莫。
=======================================================================================
一、CString与LPCWSTR
两者的不同：LPCWSTR 是Unicode字符串指针，初始化时串有多大，申请空间就有多大，以后存贮若超过则出现无法预料的结果，这是它与CString的不同之处。而CString是一个串类，内存空间类会自动管理。
1、 CString转换成LPCWSTR
方法一：CString strFileName;
LPCWSTR lpcwStr = strFileName.AllocSysString();
方法二：CString str=_T("TestStr");
USES_CONVERSION;
LPCWSTR lpcwStr = A2CW((LPCSTR)str);
MFC中CString和LPSTR是可以通用（在Unicode字符集中不成立），其中A2CW表示(LPCSTR) -> (LPCWSTR)，USER_CONVERSION表示用来定义一些中间变量，在使用ATL的转换宏之前必须定义该语句。
2、LPCWSTR转换成CString
LPCWSTR lpcwStr = L"TestWStr";
CString str(lpcwStr); //CString的其中一个构造函数
二、CString与LPWSTR
1、CString转LPWSTR
CString str;
LPWSTR lpstr = (LPWSTR)(LPCWSTR)str;
2、LPWSTR转CString （一般没有用）
LPWSTR lpwStr = L"TestWStr";
CString str(lpwStr); //CString的其中一个构造函数
1、CString转换成LPSTR:
方法一：CString strFileName;
LPSTR lpStr = strFileName.GetBuffer();
strFileName.ReleaseBuffer();
方法二：（比较下CString转LPWSTR，都是先强制转成const字符常量，然后再强制转成字符变量）
CString strFileName;
LPSTR lpStr = (LPSTR)(LPCSTR)strFimeName;
2、 LPSTR转换成CString（利用CString的构造函数）:
LPSTR lpStr = L"TestStr";
CString str(lpStr);
注意：CString和LPCSTR可直接转换，如下:
CString str;
LPCSTR lpcStr = (LPCSTR)str;
四、CString和char*转换
CString 是一种很特殊的 C++对象，它里面包含了三个值：一个指向某个数据缓冲区的指针、一个是该缓冲中有效的字符记数(它是不可存取的，是位于 CString 地址之下的一个隐藏区域)以及一个缓冲区长度。有效字符数的大小可以是从0到该缓冲最大长度值减1之间的任何数（因为字符串结尾有一个NULL字符）。字符记数和缓冲区长度被巧妙隐藏。
(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*（非unicode字符集）
若将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 中的内容（因为CString是字符串常量，和LPCSTR等价），它有一个特殊的方法可以使用，那就是GetBuffer，它的作用是返回一个可写的缓冲指针。
如果你只是打算修改字符或者截短字符串，例如：
CString s(_T("Char test"));
LPTSTR p = s.GetBuffer();
LPTSTR dot = strchr(p, ''.'');
// 在这里添加使用p的代码
if(p != NULL)
*p = _T('');
s.ReleaseBuffer(); //
使用完后及时释放，以便能使用其它的CString成员函数
char *p;
CString str="hello";
p=str.GetBuffer(str.GetLength());
str.ReleaseBuffer();将CString转换成char * 时
----
CString str("aaaaaaa");
strcpy(str.GetBuffer(10),"aa");
str.ReleaseBuffer();
五、CString和int、float的转换
可以使用atoi,atof,atol等函数来完成。
CString strFloat; float flt; //method1: flt = (float)atof((char *)(LPTSTR)(LPCTSTR)mstrFloat);//强制转换，不推荐 //method2: flt = (float)atof((char *)m_eps.GetBuffer(strFloat.GetLength())); strFloat.ReleaseBuffer();
六、LPSTR(char*)和LPWSTR的转换
可以使用下面的ATL宏来进行，最好是将变量定义成TCHAR、LPTSTR等T类型，可以避免转换。
ATL宏介绍：
A2BSTR OLE2A T2A W2A
A2COLE OLE2BSTR T2BSTR W2BSTR
A2CT OLE2CA T2CA W2CA
A2CW OLE2CT T2COLE W2COLE
A2OLE OLE2CW T2CW W2CT
A2T OLE2T T2OLE W2OLE
A2W OLE2W T2W W2T
A ：ANSI 字符串，也就是 MBCS。
W、OLE 宽字符串，也就是 UNICODE。
T 中间类型T。如果定义了 _UNICODE，则T表示W；如果定义了 _MBCS，则T表示A
C const 的缩写
利用这些宏，可以快速的进行各种字符间的转换。使用前必须包含头文件，并且申明USER_CONVERSION；使用 ATL 转换宏，由于不用释放临时空间，所以使用起来非常方便。但是考虑到栈空间的尺寸（VC 默认2M），使用时要注意几点：
1、只适合于进行短字符串的转换；
2、不要试图在一个次数比较多的循环体内进行转换；
3、不要试图对字符型文件内容进行转换，因为文件尺寸一般情况下是比较大的；
4、对情况 2 和 3，要使用 MultiByteToWideChar() 和 WideCharToMultiByte()；
void Func1(LPSTR lpStr);
void Func2(LPWSTR lpwStr);
TCHAR name[256];
TCHAR* pName = new TCHAR[256];
Func1(name); // Func1(pName);
Func2(name); // Func2(pName);
（说明）注意在VS2005中上面用红色标记的代码已经不成立。VS2005中CString已经改为宽字符型，一些转换如下：
char name[10];
TCHAR sex[5] ;
char *p = name;
TCHAR *pw = sex;
LPSTR lpstr = name;
LPCSTR lpcstr = name;
lpcstr = lpstr;//可直接赋值，字符变量给字符常量赋值
lpstr = p; //本来相等
----------------------------------------------------------------------------
p = (char*)sex;
pw = (WCHAR*)name;
LPWSTR lpwstr = (LPWSTR)lpstr;
LPCWSTR lpcwstr = (LPCWSTR)lpstr;
lpwstr = (LPWSTR)lpcstr;
lpcwstr = (LPCWSTR)name;
--------------------------------------------------------------------------
//采用CString的构造函数
CString str(lpstr);
CString str1(lpcstr);
CString str2(lpwstr);
CString str3(lpcwstr);
CString str4(name);
CString str5(sex);
//特别注意，此处的转换方式，CString与LPSTR, LPCSTR, 都是先转成宽字符，然后再转成对应的类型（见上面红色说明）
lpwstr = (LPWSTR)(LPCWSTR)str;
lpstr = (LPSTR)(LPCWSTR)str;//在Unicode编码下不成立，不能强制转换
lpcstr = (LPCSTR)(LPCWSTR)str;
p = (char*)str.GetBuffer();//错误，不能强制转换
pw = str.GetBuffer();
可以看出转换更加简单了，基本上可以直接转换，A2W等宏基本上不需要啦
测试如下代码会出现乱码，需注意（在VS2008的ATL工程下,unicode字符集），强制转换会出错
LPCSTR p3="*"; LPCWSTR lpcwStr3 = (LPCWSTR)p3; MessageBox(lpcwStr3);如下代码正确（在ATL中添加了MFC支持），采用CString中间转换可以
LPCSTR p="*"; CString strFileName(p); LPCWSTR lpcwStr = strFileName.AllocSysString(); MessageBox(lpcwStr);或者下面也正确
LPCSTR p3="*3"; CString strFileName3(p3); LPCWSTR lpcwStr3 = (LPCWSTR)strFileName3; MessageBox(lpcwStr3);CString转wchar_t*
CString theString=_T("你好！");
wchar_t* lpsz = new wchar_t[theString.GetLength()+1];
_tcscpy(lpsz, theString);
MessageBox(lpsz);或者
CString theString=_T("你好！");
wchar_t* wcs=theString.GetBuffer();
MessageBox(wcs);
wcs=NULL;
theString.ReleaseBuffer();//此处要释放或者
CString theString=_T("你好！");
LPCWSTR lpcwStr = theString.AllocSysString();
MessageBox(lpcwStr);
在没有MFC支持的情况下，参考下面的内容
===========================================================
多字节字符串与宽字符串的转换可使用C API者Win32 API.C API: mbstowcs,wcstombsWin32 API: MultiByteToWideChar, WideCharToMultiByte下面着重介绍Win32 API的用法，C API的用法较为简单可参照Win32 API。首先是WideCharToMultiByte通常你需要配置4个参数(其他参数如是使用即可)，依次是源宽字符串，需要转换的长度(-1,则为转换整个字符串)，目标多字节字符串，目标缓冲区长度。返回值表示转换为目标多字节字符串实际需要的长度(包括结束符)。所以通常需要调用WideCharToMultiByte两次：第一次产生目标缓冲区长度，第二次产生目标字符串，像下面这样
wchar_t* wcs = L"中国，你好！I Love You!"; int lengthOfMbs = WideCharToMultiByte( CP_ACP, 0, wcs, -1, NULL, 0, NULL, NULL); char* mbs = new char[ lengthOfMbs ]; WideCharToMultiByte( CP_ACP, 0, wcs, -1, mbs, lengthOfMbs, NULL, NULL); delete mbs; mbs = NULL; //============= char* mbs = "中国，你好！I Love You!"; int lengthOfWcs = MultiByteToWideChar( CP_ACP, 0, mbs, -1, NULL, 0 ); wchar_t* wcs = new wchar_t[ lengthOfWcs ]; MultiByteToWideChar( CP_ACP, 0, mbs, -1, wcs, lengthOfWcs ); delete wcs; wcs = NULL;
测试如下，正确、无乱码
//============= char* mbs2 = "中国，你好！I Love You!"; int lengthOfWcs = MultiByteToWideChar( CP_ACP, 0, mbs2, -1, NULL, 0 ); wchar_t* wcs2 = new wchar_t[ lengthOfWcs ]; MultiByteToWideChar( CP_ACP, 0, mbs2, -1, wcs2, lengthOfWcs ); LPCWSTR lpcwStr2 = (LPCWSTR)wcs2; MessageBox(lpcwStr2); delete wcs2; wcs2 = NULL;
将CString转为char* LPSTR
CString mstr=_T("您好！");
char* mc= (LPSTR)(LPCWSTR)mstr;//此处错误
//先转成宽字符串，然后再利用WideCharToMultiByte方法
wchar_t* wcs=mstr.GetBuffer();
int lengthOfMbs = WideCharToMultiByte( CP_ACP, 0, wcs, -1, NULL, 0, NULL, NULL);
char* mbs = new char[ lengthOfMbs ];
WideCharToMultiByte( CP_ACP, 0, wcs, -1, mbs, lengthOfMbs, NULL, NULL);
CString cs(mbs);
MessageBox(cs);转载
//将单字节char*转化为宽字节wchar_t*
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;
}
===========================================================================================
也谈C++中char*与wchar_t*之间的转换
关于C++中的char*与wchar_t*这两种类型的相互转换，网上说的大多很繁琐，可行性也不高。下面这个方法是在MSDN里面找到的，个人认为还比较不错：
把char*转换为wchar_t*
用stdlib.h中的mbstowcs_s函数，可以通过下面的例子了解其用法：
char *CStr ="string to convert";
size_t len = strlen(CStr) + 1;
size_t converted = 0;
wchar_t *WStr;
WStr=(wchar_t*)malloc(len*sizeof(wchar_t));
mbstowcs_s(&converted, WStr, len, CStr, _TRUNCATE);
其结果是WStr中储存了CStr的wchar_t版本。
把wchar_t*转换为char*
和上面的方法类似，用stdlib.h中的wcstombs_s函数，例子：
wchar_t *WStr = L"string to convert";
size_t len = wcslen(WStr) + 1;
size_t converted = 0;
char *CStr;
CStr=(char*)malloc(len*sizeof(char));
wcstombs_s(&converted, CStr, len, WStr, _TRUNCATE);
这时WStr中的内容将被转化为char版本储存在CStr中。
另外还可以通过流的方法来char*类型转换为wchar_t*类型，但这样的转换得到的结果将是const类型，而类似的方法不能将wchar_t*类型转换为char*类型。
把（const）char*转换为const wchar_t*
需要用到 sstream 头文件：
char *cstr="string to convert";
wstringstream wss;
wss<<cstr;
再调用wss.str().c_str();即可得到 const wchar_t*类型的返回值。
虽然stringstream流不能将wchar_t*转换成char*，但可以用来进行数值类型和字符串之间的转换，例如：
double d=2734792.934f;
stringstream ss;
ss<<d;
调用ss.str()可得到string类型字符串 ”273479e+006”，又如：
string str("299792458");
stringstream ss;
long i=0;
ss<<str;
ss>>i;
此时i=299792458。===========================================================
首先在编译程序时经常会遇到这种问题：
错误 1 error C2664: “CWnd::MessageBoxW”: 不能将参数 1 从“const char [3]”转换为“LPCTSTR”
1、觉得很烦，一般的做法就是不管三七二十一，在字符串前面加一个‘L’：
如调用函数FUN(LPCTSTR str)时，不能 FUN("HELLO"); 而是FUN(L"HELLO");通常这样做都比较能解决问题。
2、或者还可以用_T()， 即 FUN(_T("HELLO")); _T() 的别名还有 _TEXT(), TEXT()。
稍微研究了下，BSTR,LPSTR,LPWSTR,LPCTSTR,LPTSTR等这些让人头晕的东东。（还是C#里简单啊，直接tostring）
BSTR：是一个OLECHAR*类型的Unicode字符串，是一个COM字符串，带长度前缀，与VB有关，没怎么用到过。
LPSTR：即 char *，指向以'/0'结尾的8位（单字节）ANSI字符数组指针
LPWSTR：即wchar_t *，指向'/0'结尾的16位（双字节）Unicode字符数组指针
LPCSTR：即const char *
LPCWSTR：即const wchar_t *
注意下面两个类型
LPTSTR：LPSTR、LPWSTR两者二选一，取决于是否宏定义了UNICODE或ANSI
LPCTSTR： LPCSTR、LPCWSTR两者二选一，取决于是否宏定义了UNICODE或ANSI，如下是从MFC库中拷来的：
#ifdef UNICODE
typedef LPWSTR LPTSTR;
typedef LPCWSTR LPCTSTR;
#else
typedef LPSTR LPTSTR;
typedef LPCSTR LPCTSTR;
#endif
3、相互转换方法：
LPWSTR->LPTSTR: W2T();
LPTSTR->LPWSTR: T2W();
LPCWSTR->LPCSTR: W2CT();
LPCSTR->LPCWSTR: T2CW();
ANSI->UNICODE: A2W();
UNICODE->ANSI: W2A();
另外，CString转为CStringW方法(通过一个wchar_t数组来转)
CString str;
CStringW strw;
wchar_t *text = new wchar_t[sizeof(wchar_t) * str.GetLength()];
MultiByteToWideChar(CP_ACP,0,str,-1,text,str.GetLength());
strw = text;
4、另外，还可以强行转换，不过不一定能成功
5、还有_bstr_t ( 对BTSTR的封装，需要#include<comdef.h> )，也可将单字节字符数组指针转为双字节字符数组指针，还没怎么没用到过。
==========================================================
L表示long指针
这是为了兼容Windows 3.1等16位操作系统遗留下来的，在win32中以及其他的32为操作系统中， long指针和near指针及far修饰符都是为了兼容的作用。没有实际意义。
P表示这是一个指针
C表示是一个常量
T表示在Win32环境中， 有一个_T宏，这个宏用来表示你的字符是否使用UNICODE, 如果你的程序定义了UNICODE或者其他相关的宏，那么这个字符或者字符串将被作为UNICODE字符串，否则就是标准的ANSI字符串。
STR表示这个变量是一个字符串
所以LPCTSTR就表示一个指向常固定地址的可以根据一些宏定义改变语义的字符串。或者为LPCSTR ，或者为LPCWSTR
同样， LPCSTR就只能是一个ANSI字符串，在程序中我们大部分时间要使用带T的类型定义。
LPCTSTR == const TCHAR *
CString 和 LPCTSTR 可以说通用。 原因在于CString定义的自动类型转换，没什么奇特的，最简单的C++操作符重载而已。
常量字符串ansi和unicode的区分是由宏_T来决定的。但是用_T("abcd")时，字符串"abcd"就会根据编译时的是否定一_UNICODE来决定是char* 还是 w_char*。 同样，TCHAR 也是相同目的字符宏。看看定义就明白了。简单起见，下面只介绍 ansi 的情况，unicode 可以类推。
ansi情况下，LPCTSTR 就是 const char*, 是常量字符串（不能修改的）。
而LPTSTR 就是 char*, 即普通字符串（非常量，可修改的）。
这两种都是基本类型， 而CString 是 C++类， 兼容这两种基本类型是最起码的任务了。
由于const char* 最简单（常量，不涉及内存变更，操作迅速）， CString 直接定义了一个类型转换函数
operator LPCTSTR() {......}， 直接返回他所维护的字符串。
当你需要一个const char* 而传入了CString时， C++编译器自动调用 CString重载的操作符 LPCTSTR()来进行隐式的类型转换。
当需要CString , 而传入了 const char* 时（其实 char* 也可以），C++编译器则自动调用CString的构造函数来构造临时的 CString对象。
因此CString 和 LPCTSTR 基本可以通用。
CString 转LPCTSTR:
CString cStr;
const char *lpctStr=(LPCTSTR)cStr;
LPCTSTR转CString:
LPCTSTR lpctStr;
CString cStr=lpctStr;
但是 LPTSTR又不同了，他是 char*， 意味着你随时可能修改里面的数据，这就需要内存管理了(如字符串变长，原来的存贮空间就不够了，则需要重新调整分配内存)。
所以 不能随便的将 const char* 强制转换成 char* 使用。
楼主举的例子
LPSTR lpstr = (LPSTR)(LPCTSTR)string;
就是这种不安全的使用方法。
这个地方使用的是强制类型转换，你都强制转换了，C++编译器当然不会拒绝你，但同时他也认为你确实知道自己要做的是什么。因此是不会给出警告的。
强制的任意类型转换是C(++)的一项强大之处，但也是一大弊端。这一问题在 vc6 以后的版本(仅针对vc而言)中得到逐步的改进(你需要更明确的类型转换声明)。
其实在很多地方都可以看到类似
LPSTR lpstr = (LPSTR)(LPCTSTR)string;
地用法，这种情况一般是函数的约束定义不够完善的原因，比如一个函数接受一个字符串参数的输入，里面对该字符串又没有任何的修改，那么该参数就应该定义成 const char*，但是很多初学者弄不清const地用法，或者是懒， 总之就是随意写成了 char* 。 这样子传入CString时就需要强制的转换一下。
这种做法是不安全的，也是不被建议的用法，你必须完全明白、确认该字符串没有被修改。
CString 转换到 LPTSTR (char*), 预定的做法是调用CString的GetBuffer函数，使用完毕之后一般都要再调用ReleaseBuffer函数来确认修改 (某些情况下也有不调用ReleaseBuffer的，同样你需要非常明确为什么这么做时才能这样子处理，一般应用环境可以不考虑这种情况)。
同时需要注意的是， 在GetBuffer 和 ReleaseBuffer之间，CString分配了内存交由你来处理，因此不能再调用其他的CString函数。
=============================================================
1.区别wchar_t,char,WCHAR
ANSI：即 char，可用字符串处理函数：strcat( ),strcpy( ), strlen( )等以str打头的函数。
UNICODE：wchar_t是Unicode字符的数据类型，它实际定义在里：
typedef unsigned short wchar_t;
另外，在头文件中有这样的定义：typedef wchar_t WCHAR; 所以WCHAR实际就是wchar_t
wchar_t 可用字符串处理函数：wcscat(),wcscpy(),wcslen()等以wcs打头的函数。为了让编译器识别Unicode字符串，必须以在前面加一个“L”,例如: wchar_t *szTest=L"This is a Unicode string.";
2.TCHAR
在C语言里面提供了 _UNICODE宏（有下划线），在Windows里面提供了UNICODE宏（无下划线），只要定了_UNICODE宏和UNICODE宏，系统就会自 动切换到UNICODE版本，否则，系统按照ANSI的方式进行编译和运行。只定义了宏并不能实现自动的转换，他还需要一系列的字符定义支持。
1． TCHAR
如果定义了UNICODE宏则TCHAR被定义为wchar_t。
typedef wchar_t TCHAR;
否则TCHAR被定义为char typedef char TCHAR;
2． LPTSTR
如果定义了UNICODE宏则LPTSTR被定义为LPWSTR。
typedef LPTSTR LPWSTR;
否则TCHAR被定义为char typedef LPTSTR LPSTR;
说明：在使用字符串常量的时候需要使用_TEXT(“MyStr”)或者_T("")来支持系统的自动转换。
3.BSTR
BSTR是一个带长度前缀的字符串,主要由操作系统来管理的,所以要用api.主要用来和VB打交道的(VB里的string就是指它)要操作它的API函数有很多.比如SysAllocString,SysFreeString等等.
vc里封装它的类如_bstr_t,及ATL中的CComBSTR等.
一个 BSTR 由头部和字符串组成，头部包含了字符串的长度信息，字符串中可以包含嵌入的 null 值。
BSTR 是以指针的形式进行传递的。(指针是一个变量，包含另外一个变量的内存地址，而不是数据。) BSTR 是 Unicode 的，即每个字符需要两个字节。 BSTR 通常以两字节的 null 字符结束。 wstr是宽字符，以双字节表示一个字符 bstr是为了与原先的basic字符兼容，它的最前面的4个字节为其长度，以'\0'结束.
4.更进一步的字符串以及其指针的类型定义
由于Win32 API文档的函数列表使用函数的常用名字（例如， "SetWindowText"），所有的字符串都是用TCHAR来定义的。（除了XP中引入的只适用于Unicode的API）。下面列出一些常用的typedefs，你可以在msdn中看到他们。
type Meaning in MBCS builds Meaning in Unicode builds
WCHAR wchar_t wchar_t
LPSTR char* char*
LPCSTR const char* const char*
LPWSTR wchar_t* wchar_t*
LPCWSTR wchar_t* wchar_t*
TCHAR TCHAR char wchar_t
LPTSTR TCHAR* TCHAR*
LPCTSTR const TCHAR* const TCHAR*
5.相互转换
(1) char*转换成CString
若将char*转换成CString，除了直接赋值外，还可使用CString::Format进行。例如：
char chArray[] = "This is a test";
char * p = "This is a test";
或
LPSTR p = "This is a test";
或在已定义Unicode应的用程序中
TCHAR * p = _T("This is a test");
或
LPTSTR p = _T("This is a test");
CString theString = chArray;
theString.Format(_T("%s"), chArray);
theString = p;
(2) CString转换成char*
若将CString类转换成char*(LPSTR)类型，常常使用下列三种方法：
方法一，使用强制转换。例如：
CString theString( "This is a test" );
LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString;
方法二，使用strcpy。例如：
CString theString( "This is a test" );
LPTSTR lpsz = new TCHAR[theString.GetLength()+1];
_tcscpy(lpsz, theString);
需要说明的是，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。例如：
#include
#pragma comment(lib, "comsupp.lib")
int _tmain(int argc, _TCHAR* argv[]){
BSTR bstrText = ::SysAllocString(L"Test");
char* lpszText2 = _com_util::ConvertBSTRToString(bstrText);
SysFreeString(bstrText); // 用完释放
delete[] lpszText2;
return 0;
}
方法二，使用_bstr_t的赋值运算符重载。例如：
_bstr_t b = bstrText;
char* lpszText2 = b;
(4) char*转换成BSTR
方法一，使用SysAllocString等API函数。例如：
BSTR bstrText = ::SysAllocString(L"Test");
BSTR bstrText = ::SysAllocStringLen(L"Test",4);
BSTR bstrText = ::SysAllocStringByteLen("Test",4);
方法二，使用COleVariant或_variant_t。例如：
//COleVariant strVar("This is a test");
_variant_t strVar("This is a test");
BSTR bstrText = strVar.bstrVal;
方法三，使用_bstr_t，这是一种最简单的方法。例如：
BSTR bstrText = _bstr_t("This is a test");
方法四，使用CComBSTR。例如：
BSTR bstrText = CComBSTR("This is a test");
或
CComBSTR bstr("This is a test");
BSTR bstrText = bstr.m_str;
方法五，使用ConvertStringToBSTR。例如：
char* lpszText = "Test";
BSTR bstrText = _com_util::ConvertStringToBSTR(lpszText);
(5) CString转换成BSTR
通常是通过使用CStringT::AllocSysString来实现。例如：
CString str("This is a test");
BSTR bstrText = str.AllocSysString();
…
SysFreeString(bstrText); // 用完释放
(6) BSTR转换成CString
一般可按下列方法进行：
BSTR bstrText = ::SysAllocString(L"Test");
CStringA str;
str.Empty();
str = bstrText;
或
CStringA str(bstrText);
(7) ANSI、Unicode和宽字符之间的转换
方法一，使用MultiByteToWideChar将ANSI字符转换成Unicode字符，使用WideCharToMultiByte将Unicode字符转换成ANSI字符。
方法二，使用“_T”将ANSI转换成“一般”类型字符串，使用“L”将ANSI转换成Unicode，而在托管C++环境中还可使用S将ANSI字符串转换成String*对象。例如：
TCHAR tstr[] = _T("this is a test");
wchar_t wszStr[] = L"This is a test";
String* str = S”This is a test”;
方法三，使用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转换成一般类型的字符串常量。下面 是一些示例代码：
LPTSTR tstr= CA2TEX<16>("this is a test");
LPCTSTR tcstr= CA2CT("this is a test");
wchar_t wszStr[] = L"This is a test";
char* chstr = CW2A(wszStr);
转自：
http://www.cnblogs.com/chenleiustc/archive/2011/04/09/2010647.html
根据ANSI C标准的赋值约束条件：
1. 两个操作数都是指向有限定符或无限定符的相容类型的指针。
2. 左边指针所指向的类型必须具有右边指针所指向类型的全部限定符。
一、const char*和char*
const char*的类型是：“指向一个具有const限定符的char类型的指针”。（不能修改其值）
char*的类型是：“指向一个char类型的指针”。
因此const char*和char*都是指向char类型的指针，只不过const char*指向的char类型是const的。
因此对于代码：
char* src;
const char* dest ;
dest = src;
这样赋值是正确的，因为:
* 操作数指向的都是char类型，因此是相容的
* 左操作数具有有操作数所指向类型的全部限定符（右操作数没有限定符），同时自己有限定符（const）
如果反过来赋值就违反了赋值的约束条件：src指向的对象的值可以修改，而dest指向的对象的值不可修改
如果让src去指向dest所指向的那个不可修改的对象，如果合法，岂不是变得可修改了？
src = dest; // 这样赋值，左操作数指向的类型没有右操作数指向类型的const限定符，不符合约束条件2
2. const char** 和char**
const char**的类型是：“指向一个有const限定符的char类型的指针的指针”。
char**的类型是：“指向一个char类型的指针的指针”。
对于const char** 和char**来说，二者都是没有限定符的指针类型，但是它们指向的类型不一样，前者指向char*， 而后者指向const char*，因此它们不相容，所以char**类型的操作数不能赋值给const char**类型的操作数。
即对于下列代码，编译器会报错：char** src;
const char** dest;
dest = src;
// error: invalid conversion from `char**' to `const char**'
-------------------------------------------------------------------------------------------------------------
const
1. 限定符声明变量只能被读
const int i=5;
int j=0;
...
i=j; //非法，导致编译错误
j=i; //合法
2. 必须初始化
const int i=5; //合法
const int j; //非法，导致编译错误
3. 在另一连接文件中引用const常量
extern const int i; //合法
extern const int j=10; //非法，常量不可以被再次赋值
4. 便于进行类型检查
用const方法可以使编译器对处理内容有更多了解。
#define I=10
const long &i=10; /*dapingguo提醒：由于编译器的优化，使得在const long i=10; 时i不被分配内存，而是已10直接代入 以后的引用中，以致在以后的代码中没有错误，为达到说教效 果，特别地用&i明确地给出了i的内存分配。 不过一旦你关闭所 有优化措施，即使const long i=10;也会引起后面的编译错误。*/
char h=I; //没有错
char h=i; //编译警告，可能由于数的截短带来错误赋值。
5. 可以避免不必要的内存分配
#define STRING "abcdefghijklmn\n"
const char string[]="abcdefghijklm\n";
...
printf(STRING); //为STRING分配了第一次内存
printf(string); //为string一次分配了内存，以后不再分配
...
printf(STRING); //为STRING分配了第二次内存
printf(string);
...
由于const定义常量从汇编的角度来看，只是给出了对应的内存地址，
而不是象#define一样给出的是立即数，所以，const定义的常量在
程序运行过程中只有一份拷贝，而#define定义的常量在内存中有
若干个拷贝。
6. 可以通过函数对常量进行初始化
int value();
const int i=value();
dapingguo说：假定对ROM编写程序时，由于目标代码的不可改写，本语句将会无效，不过可以变通一下：
const int &i=value();
只要令i的地址处于ROM之外，即可实现：i通过函数初始化，而其值有不会被修改。
7. 是不是const的常量值一定不可以被修改呢？
观察以下一段代码：
const int i=0;
int *p=(int*)&i;
p=100;
通过强制类型转换，将地址赋给变量，再作修改即可以改变const常量值。
8. 请分清数值常量和指针常量，以下声明颇为玩味：
int ii=0;
const int i=0; //i是常量，i的值不会被修改
const int *p1i=&i; //指针p1i所指内容是常量，可以不初始化
int * const p2i=ⅈ //指针p2i是常量，所指内容可修改
const int * const p3i=&i; //指针p3i是常量，所指内容也是常量
p1i=ⅈ //合法
*p2i=100; //合法
关于C++中的const关键字的用法非常灵活，而使用const将大大改善程序的健壮性，参考了康建东兄的const使用详解一文，对其中进行了一些补充，写下了本文。
1. const常量，如const int max = 100;
优点：const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误（边际效应）
2. const 修饰类的数据成员。如：
class A
{
const int size;
… }
const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类声明中初始化const数据成员，因为类的对象未被创建时，编译器不知道const 数据成员的值是什么。如
class A
{
const int size = 100; //错误
int array[size]; //错误，未知的size
}
const数据成员的初始化只能在类的构造函数的初始化表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现。如
class A
{…
enum {size1=100, size2 = 200 };
int array1[size1];
int array2[size2];
}
枚举常量不会占用对象的存储空间，他们在编译时被全部求值。但是枚举常量的隐含数据类型是整数，其最大值有限，且不能表示浮点数。
3. const修饰指针的情况，见下式：
int b = 500;
const int* a = & [1]
int const *a = & [2]
int* const a = & [3]
const int* const a = & [4]
如果你能区分出上述四种情况，那么，恭喜你，你已经迈出了可喜的一步。不知道，也没关系，我们可以参考《Effective c++》Item21上的做法，如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的 右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无 关），这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常 量。
4. const的初始化
先看一下const变量初始化的情况
1) 非指针const常量初始化的情况：A b;
const A a = b;
2) 指针const常量初始化的情况：
A* d = new A();
const A* c = d;
或者：const A* c = new A();
3）引用const常量初始化的情况：
A f;
const A& e = f; // 这样作e只能访问声明为const的函数，而不能访问一
般的成员函数；
[思考1]： 以下的这种赋值方法正确吗？
const A* c=new A();
A* e = c;
[思考2]： 以下的这种赋值方法正确吗？
A* const c = new A();
A* b = c;
5. 另外const 的一些强大的功能在于它在函数声明中的应用。在一个函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。有如下几种情况，以下会逐渐的说明用法：A& operator=(const A& a);
void fun0(const A* a );
void fun1( ) const; // fun1( ) 为类成员函数
const A fun2( );
1） 修饰参数的const，如 void fun0(const A* a ); void fun1(const A& a);
调 用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const A* a，则不能对传递进来的指针的内容进行改变，保护了原指针所指向的内容；如形参为const A& a，则不能对传递进来的引用对象进行改变，保护了原对象的属性。
[注意]：参数const通常用于参数为指针或引用的情况，且只能修饰输入参数;若输入参数采用“值传递”方式，由于函数将自动产生临时变量用于复制该参数，该参数本就不需要保护，所以不用const修饰。
[总结]对于非内部数据类型的输入参数，因该将“值传递”的方式改为“const引用传递”，目的是为了提高效率。例如，将void Func(A a)改为void Func(const A &a)
对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x)不应该改为void Func(const int &x)
2） 修饰返回值的const，如const A fun2( ); const A* fun3( );
这样声明了返回值后，const按照"修饰原则"进行修饰，起到相应的保护作用。const Rational operator*(const Rational& lhs, const Rational& rhs)
{
return Rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}
返回值用const修饰可以防止允许这样的操作发生:Rational a,b;
Radional c;
(a*b) = c;
一般用const修饰返回值为对象本身（非引用和指针）的情况多用于二目操作符重载函数并产生新对象的时候。 [总结]
1. 一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对 某个对象引用的情况。原因如下：如果返回值为某个对象为const（const A test = A 实例）或某个对象的引用为const（const A& test = A实例） ，则返回值具有const属性，则返回实例只能访问类A中的公有（保护）数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少 用到。
2. 如果给采用“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。如：
const char * GetString(void);
如下语句将出现编译错误：
char *str=GetString();
正确的用法是：
const char *str=GetString();
3. 函数返回值采用“引用传递”的场合不多，这种方式一般只出现在类的赙值函数中，目的是为了实现链式表达。如：
class A
{…
A &operate = (const A &other); //负值函数
}
A a,b,c; //a,b,c为A的对象
…
a=b=c; //正常
(a=b)=c; //不正常，但是合法
若负值函数的返回值加const修饰，那么该返回值的内容不允许修改，上例中a=b=c依然正确。(a=b)=c就不正确了。
[思考3]： 这样定义赋值操作符重载函数可以吗？
const A& operator=(const A& a);
6. 类成员函数中const的使用
一般放在函数体后，形如：void fun() const;
任何不会修改数据成员的函数都因该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其他非const成员函数，编译器将报错，这大大提高了程序的健壮性。如：
class Stack
{
public:
void Push(int elem);
int Pop(void);
int GetCount(void) const; //const 成员函数
private:
int m_num;
int m_data[100];
};
int Stack::GetCount(void) const
{
++m_num; //编译错误，企图修改数据成员m_num
Pop(); //编译错误，企图调用非const函数
Return m_num;
}
7. 使用const的一些建议
1 要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
2 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
3 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
4 const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
5 不要轻易的将函数的返回值类型定为const;
6除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;
[思考题答案]
1 这种方法不正确，因为声明指针的目的是为了对其指向的内容进行改变，而声明的指针e指向的是一个常量，所以不正确；
2 这种方法正确，因为声明指针所指向的内容可变；
3 这种做法不正确；
在const A::operator=(const A& a)中，参数列表中的const的用法正确，而当这样连续赋值的时侯，问题就出现了：
A a,b,c:
(a=b)=c;
因为a.operator=(b)的返回值是对a的const引用，不能再将c赋值给const常量。
C函数形参里面为何要用:const char *inputString
保护实参指针指向的数据不被意外改写。
const char *inputString;//定义指向常量的指针
指针本身地址值可以增减，也可以给指针更换指向的常量，但是指向的内容有常量性质，指向的内容不能被更改。即：
inputString++;//这是可以的。
(*inputString)++;//这是禁止的。
强制类型转换的实质是告诉编译器,"这可行, 这行的通... 至于程序会不会出错, 编译器则不管, 因为你都说可行了."
两个操作数都是指向有限定符或无限定符的相容类型的指针，左边指针所指向的类型必须具有右边指针所指向类型的全部限定符。
正是这个条件，使得函数调用中实参char *能够与形参const char *匹配（在C标准库中，所有的字符串处理函数就是这样的）。
函数那部分的时候，有一个很重要的概念是区别：值传递、指针传递、引用传值(好像是这三种说法)。
我觉得要理解这部分知识点，首先应该知道不同种类的变量在内存中是如何分配存储的，它们的生命周期多长等这些问题，然后在理解哪三种情况就好理解了。函数的参数一般都
是在stack栈上分配的，所以它的生命周期就在它所属的函数内，函数执行完毕的时候，它的内存将被回收。
如果我们想在函数内对实际参数进行操作(不是对形式参数的副本)的话，一般会使用引用，即声明函数的形式参数为引用类型，比如char * fun(char * &p)，这样实参和形参为同一个变量，我们在函数中操作形参p就等于直接在操作实参变量。我看C++语法书的时候，书上说这样用还有一个好处是，在调用函数的时候，不用再为形式参数分配内存了，这样执行效率会高一点儿。
下面是函数形参为指针的几种情况：
#include <iostream>
using namespace std;
char* func1(char *p);
void func2(char *p);
void func3(char * &p);
char s1[]="原来的";
char s2[]="指向我了吗";
int main()
{
char *ptr=s1;
cout<<ptr<<endl;
ptr=func1(ptr); //返回值改变ptr使它指向另一个地址
//func2(ptr); //ptr的指向没有改变，func2函数中改变的只是它的副本(一个局部变量)
//func3(ptr); //改变了ptr的指向，func3函数的形式参数为引用类型，实参和形参是同一个变量
cout<<ptr<<endl;
return 0;
}
char* func1(char *p)
{
p=s2;
return p;
}
void func2(char *p)
{
p=s2;
}
void func3(char * &p)
{
p=s2;
}
===============================
在ActiveX编程中，会涉及到BSTR字符串的转换
char*转换成CString
若将char*转换成CString，除了直接赋值外，还可使用CString::Format进行。例如：
char chArray[] = "This is a test";
char * p = "This is a test";
或
LPSTR p = "This is a test";
或在已定义Unicode应的用程序中
TCHAR * p = _T("This is a test");
或
LPTSTR p = _T("This is a test");
CString theString = chArray;
theString.Format(_T("%s"), chArray);
theString = p;
CString转换成char*
若将CString类转换成char*(LPSTR)类型，常常使用下列三种方法：
方法一，使用强制转换。例如：
CString theString( "This is a test" );
LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString;
方法二，使用strcpy。例如：
CString theString( "This is a test" );
LPTSTR lpsz = new TCHAR[theString.GetLength()+1];
_tcscpy(lpsz, theString);
需要说明的是，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成员函数
BSTR转换成char*
方法一，使用ConvertBSTRToString。例如：
#include "comutil.h"
#pragma comment(lib, "comsupp.lib")
int _tmain(int argc, _TCHAR* argv[]){
BSTR bstrText = ::SysAllocString(L"Test");
char* lpszText2 = _com_util::ConvertBSTRToString(bstrText);
SysFreeString(bstrText); // 用完释放
delete[] lpszText2;
return 0;
}
** 此方法不好，会造成内存泄露，SysFreeString也没有效果。
方法二，使用_bstr_t的赋值运算符重载。例如：
_bstr_t b = bstrText;
char* lpszText2 = b;
* 不会有内存泄露，推荐方法
char*转换成BSTR
方法一，使用SysAllocString等API函数。例如：
BSTR bstrText = ::SysAllocString(L"Test");
BSTR bstrText = ::SysAllocStringLen(L"Test",4);
BSTR bstrText = ::SysAllocStringByteLen("Test",4);
方法二，使用COleVariant或_variant_t。例如：
//COleVariant strVar("This is a test");
_variant_t strVar("This is a test");
BSTR bstrText = strVar.bstrVal;
方法三，使用_bstr_t，这是一种最简单的方法。例如：
BSTR bstrText = _bstr_t("This is a test");
方法四，使用CComBSTR。例如：
BSTR bstrText = CComBSTR("This is a test");
或
CComBSTR bstr("This is a test");
BSTR bstrText = bstr.m_str;
方法五，使用ConvertStringToBSTR。例如：
char* lpszText = "Test";
BSTR bstrText = _com_util::ConvertStringToBSTR(lpszText);
(5) CString转换成BSTR
通常是通过使用CStringT::AllocSysString来实现。例如：
CString str("This is a test");
BSTR bstrText = str.AllocSysString();
…
SysFreeString(bstrText); // 用完释放
BSTR转换成CString
一般可按下列方法进行：
BSTR bstrText = ::SysAllocString(L"Test");
CStringA str;
str.Empty();
str = bstrText;
或
CStringA str(bstrText);
NSI、Unicode和宽字符之间的转换
方法一，使用MultiByteToWideChar将ANSI字符转换成Unicode字符，使用WideCharToMultiByte将Unicode字符转换成ANSI字符。
方法二，使用“_T”将ANSI转换成“一般”类型字符串，使用“L”将ANSI转换成Unicode，而在托管C++环境中还可使用S将ANSI字符串转换成String*对象。例如：
TCHAR tstr[] = _T("this is a test");
wchar_t wszStr[] = L"This is a test";
String* str = S”This is a test”;
方法三，使用ATL 7.0的转换宏和类。ATL7.0在原有3.0基础上完善和增加了许多字符串转换宏以及提供相应的类。
其中，第一个C表示“类”，以便于ATL 3.0宏相区别，第二个C表示常量，2表示“to”，EX表示要开辟一定大小的缓冲。SourceType和DestinationType可以是A、T、W和OLE，其含义分别是ANSI、Unicode、“一般”类型和OLE字符串。例如，CA2CT就是将ANSI转换成一般类型的字符串常量。下面是一些示例代码：
LPTSTR tstr= CA2TEX<16>("this is a test");
LPCTSTR tcstr= CA2CT("this is a test");
wchar_t wszStr[] = L"This is a test";
char* chstr = CW2A(wszStr);
=======================================================================================
一、BSTR、LPSTR和LPWSTR
在VisualC++.NET的所有编程方式中，我们常常要用到这样的一些基本字符串类型，如BSTR、LPSTR和LPWSTR等。之所以出现类似上述的这些数据类型，是因为不同编程语言之间的数据交换以及对ANSI、Unicode和多字节字符集(MBCS)的支持。
那么什么是BSTR、LPSTR以及LPWSTR呢？
BSTR(BasicSTRing，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 genericstring”，表示“一个指向一般字符串常量的长指针类型”，与C/C++的constchar*相映射，而LPTSTR映射为 char*。
一般地，还有下列类型定义：
#ifdef UNICODE
typedef LPWSTR LPTSTR;
typedef LPCWSTR LPCTSTR;
#else
typedef LPSTR LPTSTR;
typedef LPCSTR LPCTSTR;
#endif
二、CString、CStringA 和 CStringW
VisualC++.NET中将CStringT作为ATL和MFC的共享的“一般”字符串类，它有CString、CStringA和CStringW三种形式，分别操作不同字符类型的字符串。这些字符类型是TCHAR、char和wchar_t。TCHAR在Unicode平台中等同于WCHAR(16位Unicode字符)，在ANSI中等价于char。wchar_t通常定义为unsignedshort。由于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 va;
:: VariantInit(&va); // 初始化
int a = 2002;
va.vt = VT_I4; // 指明long数据类型
va.lVal = a; // 赋值
为了方便处理VARIANT类型的变量，Windows还提供了这样一些非常有用的函数：
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相似。不过在VisualC++.NET的MFC应用程序中使用时需要在代码文件前面添加下列两句：
#include "comutil.h"
#pragma comment( lib, "comsupp.lib" )
四、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函数，其他操作是借用BSTRAPI函数。与_variant_t相似，使用时也要添加comutil.h和comsupp.lib。
五、BSTR、char*和CString转换
(3) BSTR转换成char*
方法一，使用ConvertBSTRToString。例如：
#include
#pragma comment(lib, "comsupp.lib")
int _tmain(int argc, _TCHAR* argv[]){
BSTR bstrText = ::SysAllocString(L"Test");
char* lpszText2 = _com_util::ConvertBSTRToString(bstrText);
SysFreeString(bstrText); // 用完释放
delete[] lpszText2;
return 0;
}
方法二，使用_bstr_t的赋值运算符重载。例如：
_bstr_t b = bstrText;
char* lpszText2 = b;
(4) char*转换成BSTR
方法一，使用SysAllocString等API函数。例如：
BSTR bstrText = ::SysAllocString(L"Test");
BSTR bstrText = ::SysAllocStringLen(L"Test",4);
BSTR bstrText = ::SysAllocStringByteLen("Test",4);
方法二，使用COleVariant或_variant_t。例如：
//COleVariant strVar("This is a test");
_variant_t strVar("This is a test");
BSTR bstrText = strVar.bstrVal;
方法三，使用_bstr_t，这是一种最简单的方法。例如：
BSTR bstrText = _bstr_t("This is a test");
方法四，使用CComBSTR。例如：
BSTR bstrText = CComBSTR("This is a test");
或
CComBSTR bstr("This is a test");
BSTR bstrText = bstr.m_str;
方法五，使用ConvertStringToBSTR。例如：
char* lpszText = "Test";
BSTR bstrText = _com_util::ConvertStringToBSTR(lpszText);
(5) CString转换成BSTR
通常是通过使用CStringT::AllocSysString来实现。例如：
CString str("This is a test");
BSTR bstrText = str.AllocSysString();
…
SysFreeString(bstrText); // 用完释放
(6) BSTR转换成CString
一般可按下列方法进行：
BSTR bstrText = ::SysAllocString(L"Test");
CStringA str;
str.Empty();
str = bstrText;
或
CStringA str(bstrText);
(7) ANSI、Unicode和宽字符之间的转换
方法一，使用MultiByteToWideChar将ANSI字符转换成Unicode字符，使用WideCharToMultiByte将Unicode字符转换成ANSI字符。
方法二，使用“_T”将ANSI转换成“一般”类型字符串，使用“L”将ANSI转换成Unicode，而在托管C++环境中还可使用S将ANSI字符串转换成String*对象。例如：
TCHAR tstr[] = _T("this is a test");
wchar_t wszStr[] = L"This is a test";
String* str = S”This is a test”;
方法三，使用ATL7.0的转换宏和类。ATL7.0在原有3.0基础上完善和增加了许多字符串转换宏以及提供相应的类，它具有如图3所示的统一形式：
其中，第一个C表示“类”，以便于ATL3.0宏相区别，第二个C表示常量，2表示“to”，EX表示要开辟一定大小的缓冲。SourceType和DestinationType可以是A、T、W和OLE，其含义分别是ANSI、Unicode、“一般”类型和OLE字符串。例如，CA2CT就是将ANSI转换成一般类型的字符串常量。下面是一些示例代码：
LPTSTR tstr= CA2TEX<16>("this is a test");LPCTSTR tcstr= CA2CT("this is a test");
wchar_t wszStr[] = L"This is a test";
char* chstr = CW2A(wszStr);
==============================================================
CString与LPCWSTR的转化
问题起因：在写WritePrivateProfileString写.ini配置文件时在msdn中看到，如果想要写得配置信息即时生效必须在之前使用WritePrivateProfileStringW来re-read一下目标.ini文件，其原文如下：
//
force the system to re-read the mapping into shared memory
//
so that future invocations of the application will see it
//
without the user having to reboot the system
WritePrivateProfileStringW( NULL, NULL, NULL, L
"
appname.ini
"
);
查了一下msdn中WritePrivateProfileStringW的原型如下：
WINBASEAPI BOOL WINAPI WritePrivateProfileStringW ( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString, LPCWSTR lpFileName )
其中的每个参数的类型都为LPCWSTR，实际中获得的文件名都为CString，问题产生。
问题分析：
LPCWSTR 是Unicode字符串指针，初始化时串有多大，申请空间就有多大，以后存贮若超过则出现无法预料的结果，这是它与CString的不同之处。而CString是一个串类，内存空间类会自动管理。LPCWSTR 初始化如下：
LPCWSTR Name
=
L
"
TestlpCwstr
"
;
由于LPCWSTR必须指向Unicode的字符串，问题的关键变成了Anis字符与Unicode字符之间的转换，不同编码间的转换，通过查找资料可知，可以ATL中转换宏可以用如下方法实现：
//
方法一
CString str
=
_T(
"
TestStr
"
);USES_CONVERSION;LPWSTR pwStr
=
new
wchar_t[str.GetLength()
+
1
];wcscpy(pwStr,T2W((LPCTSTR)str));
//
方法二
CString str
=
_T(
"
TestStr
"
);USES_CONVERSION;LPWCSTR pwcStr
=
A2CW((LPCSTR)str);
MFC中CString和LPSTR是可以通用，其中A2CW表示(LPCSTR) -> (LPCWSTR)，USER_CONVERSION表示用来定义一些中间变量，在使用ATL的转换宏之前必须定义该语句。
顺便也提一下，如果将LPCWSTR转换成CString，那就更加容易，在msdn中的CString类说明中提到了可以直接用LPCWSTR来构造CString，所以可以进行如下的转换代码：
LPCWSTR pcwStr
=
L
"
TestpwcStr
"
;CString str(pcwStr);
问题总结：
在头文件<atlconv.h>中定义了ATL提供的所有转换宏，如：
A2CW (LPCSTR)
->
(LPCWSTR) A2W (LPCSTR)
->
(LPWSTR) W2CA (LPCWSTR)
->
(LPCSTR) W2A (LPCWSTR)
->
(LPSTR)
所有的宏如下表所示：
| A2BSTR | OLE2A | T2A | W2A |
| A2COLE | OLE2BSTR | T2BSTR | W2BSTR |
| A2CT | OLE2CA | T2CA | W2CA |
| A2CW | OLE2CT | T2COLE | W2COLE |
| A2OLE | OLE2CW | T2CW | W2CT |
| A2T | OLE2T | T2OLE | W2OLE |
| A2W | OLE2W | T2W | W2T |
上表中的宏函数，非常的有规律，每个字母都有确切的含义如下：
| 2 | to 的发音和 2 一样，所以借用来表示“转换为、转换到”的含义。 |
| A | ANSI 字符串，也就是 MBCS。 |
| W、OLE | 宽字符串，也就是 UNICODE。 |
| T | 中间类型T。如果定义了 _UNICODE，则T表示W；如果定义了 _MBCS，则T表示A |
| C | const 的缩写 |
利用这些宏，可以快速的进行各种字符间的转换。使用前必须包含头文件，并且申明USER_CONVERSION；使用 ATL 转换宏，由于不用释放临时空间，所以使用起来非常方便。但是考虑到栈空间的尺寸（VC 默认2M），使用时要注意几点：
1、只适合于进行短字符串的转换；
2、不要试图在一个次数比较多的循环体内进行转换；
3、不要试图对字符型文件内容进行转换，因为文件尺寸一般情况下是比较大的；
4、对情况 2 和 3，要使用 MultiByteToWideChar() 和 WideCharToMultiByte()；
对于这些方面更多的知识可以参见MSDN相关文档（如：Article 3. Strings the OLE Way），问题总结中的一些资料来源于杨老师的Com编程文章http://www.vckbase.com/document/viewdoc/?id=1488，在此表示感谢。