最近很多小伙伴都在问CString,BSTR,LPCTSTR之间关系和区别和cstring_bstr_t这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展BSTR、LPSTR、LPW

最近很多小伙伴都在问CString ,BSTR ,LPCTSTR之间关系和区别和cstring _bstr_t这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展BSTR、LPSTR、LPWSTR、CString、VAvariant_t、CComBSTR、...、CString 和 LPCTSTR 之间的转换 及 LPSTR、LPWSTR、LPCSTR、LPCWSTR、LPTSTR、LPCTSTR的区分与转化、CString, BSTR, LPCTSTR 概念、CString与LPCWSTR的转化等相关知识，下面开始了哦！

• CString ,BSTR ,LPCTSTR之间关系和区别（cstring _bstr_t）
• BSTR、LPSTR、LPWSTR、CString、VAvariant_t、CComBSTR、...
• CString 和 LPCTSTR 之间的转换 及 LPSTR、LPWSTR、LPCSTR、LPCWSTR、LPTSTR、LPCTSTR的区分与转化
• CString, BSTR, LPCTSTR 概念
• CString与LPCWSTR的转化

CString ,BSTR ,LPCTSTR之间关系和区别（cstring _bstr_t）

BSTR、LPSTR、LPWSTR、CString、VAvariant_t、CComBSTR、...

Visual C++.NET 涉及到 ATL/ATL Server、MFC 和托管 C++ 等多种编程方式，不仅功能强大而且应用广泛。在编程中，我们常常会遇到 ANSI、Unicode 以及 BSTR 不同编码类 型的字符串转换操作。本文先介绍基本字符串类型，然后说明相关的类，如 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*。

一般地，还有下列类型定义：

#ifdef UNICODE
typedef LPWSTR LPTSTR;
typedef LPCWSTR LPCTSTR;
#else
typedef LPSTR LPTSTR;
typedef LPCSTR LPCTSTR;
#endif

二、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 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 相似。不过在 Visual C++.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 函数，其他操作是借用 BSTR API 函数。与_variant_t 相似，使用时也要添加 comutil.h 和 comsupp.lib。

五、BSTR、char * 和 CString 转换

(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);

六、结语

几乎所有的程序都要用到字符串，而 Visual C++.NET 由于功能强大、应用广泛，因而字符串之间的转换更为频繁。本文几乎涉及到目前的所有转换方法。当然对于.NET 框架来说，还可使用 Convert 和 Text 类进行不同数据类型以及字符编码之间的相互转换。

CString ,BSTR ,LPCTSTR 之间关系和区别

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

VC 常用数据类型使用转换详解

先定义一些常见类型变量借以说明
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

使用 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 、_variant_t 与 COleVariant

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);
关于 CString 的使用
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 的大小，
// 当 s1<s2、s1>s2 和 s1=s2 时，分别返回小于 0、大于 0 和等于 0 的值
【例】result=strcmp (”baker”,”Baker”);    //result>0
result=strcmp(”12″,”12″);        //result=0
result=strcmp(”Joe”,”joseph”)   //result<0

5、字符定位
char *strchr (char *s,char c);// 找 c 在字符串 s 中第一次出现的位置，
// 若找到，则返回该位置，否则返回 NULL
【例】p=strchr (s2,’.'');      //p 指向”file” 之后的位置
if(p) strcpy(p,”.cpp”);     //s2=”file.cpp”

注意：
①上述操作是最基本的，其中后 4 个操作还有变种形式：strncpy，strncath 和 strnchr。
②其它的串操作见 C 的 <string.h>。在不同的高级语言中，对串运算的种类及符号都不尽相同
③其余的串操作一般可由这些基本操作组合而成

【例】求子串的操作可如下实现：
void substr(char *sub,char *s,int pos,int len){
//s 和 sub 是字符数组，用 sub 返回串 s 的第 pos 个字符起长度为 len 的子串
// 其中 0<=pos<=strlen (s)-1, 且数组 sub 至少可容纳 len+1 个字符。
if (pos<0||pos>strlen(s)-1||len<0)
Error(”parameter error!”);
strncpy (sub,&s [pos],len);      // 从 s [pos] 起复制至多 len 个字符到 sub

CString 和 LPCTSTR 之间的转换 及 LPSTR、LPWSTR、LPCSTR、LPCWSTR、LPTSTR、LPCTSTR的区分与转化

转载地址：http://www.jb51.cc/article/p-auswentw-kx.html

今天在写代码的时候碰到这样的问题，网上查了一下，做了以下整理：