C S tring

CString 没有基类。

个 CString 对象由可变长度的一队字符组成。 CString 使
用类似于 Basic 的语法提供函数和操作符。连接和比较操作符以及简化的内存管理使 CString 对象比普通字符串数组容易使用。

CString 是基于 TCHAR 数据类型的对象。如果在你的程序中定义了符号

_UNICODE ，则 TCHAR 被定义为类型 wchar_t ，即 16 位字符类型；否则，TCHAR

被定义为 char，即 8 位字符类型。在 UNICODE 方式下， CString 对象由 16 位

当不使用 _UNICODE 时， CString 是多字节字符集（ MBC S ，也被认为是双字节字符集， DBCS ）。注意，对于 MBCS 字符串， CString 仍然基于 8 位字符来计算，返回，以及处理字符串，并且你的应用程序必须自己解释 MBCS 的开始和结束字节。

CString 对象还具有下列特征：

CString 可作为连接操作的结果而增大。
CString 对象遵循 “ 值语义 ” 。应将 CString 看作是一个真

实的字符串而不是指向字符串的指针。
你可以使用 C S tring 对象任意替换 Coust char* 和 LPCTSTR

函数参数。
转换操作符使得直接访问该字符串的字符就像访问一

个只读字符（ C - 风格的字符）数组一样。

提示如果可能的话，应在框架中而不是堆中分配这个 CString 对象。这可以节省内存并简化参数的传递。

CString 允许两个具有相同值的字符串共享相同的缓冲空间，这有助于你节省内存空间。但是，如果你初始直接改变该缓冲的内容（不使用 MFC ），则有可能在无意中改变了两个字符串。 CString 提供了两个成员函数 CString::LockBuffer 和 CString::UnlockBuffer 来帮助你保护你的数据。当你调用 LockBuffer 时，你就创建了一个字符串的一个拷贝，然后将引用计数设置为 -1 ，这就 “ 加锁 ” 了该缓冲区。当缓冲区被加锁时，就没有其它的字符串可以引用该字符串中的数据，被加锁的字符串也不能引用其它字符串的数据。通过加锁该缓冲区内的字符串，就可以保证该字符串对数据的持续独占。当你使用完数据后，调用UnlockBuffer 来将引用计数恢复为 1 。

更多的信息，参见 “ Visual C++ 程序员指南 ” 中的 “ MFC 字符串 ” 和 “ 字符串：

Unicode 和多字节字符集（ MBC S ）支持”，以及“ Microsoft Visual C++ 库参考 ” 中的 “ M icrosoft Visual C++ 6.0 运行库参考 ” 。

#include <afx.h>

请参阅 在 “ Visual C++ Programmer's 指南 ” 中的：字符串：基本的 CString 操作，

字符串： CString 语义，字符串： CString 与 C -Style Strings 相关的操作，

字符串： CString 异常清除，字符串： CString 参数传递

C String 类成员

CString 以各种方法构造一个 CString 对象

The String as an A rray

GetLength 返回 CString 对象中的字符数。对多字节字符，按 8 位字符计算；即在一个多字节字符中一个开始和结束字节算作两个字符

IsEmpty 测试一个 CString 对象中是否不含有字符

Empty 强制一个字符串的长度为 0

GetAt 返回在给定位置的字符

Operator[] 返回在给定位置的字符 – – – 它是代替 GetAt 的操作符

SetAt 设置给定位置上的字符

Operator LPCTSTR 象访问一个 C 风格的字符串一样，直接访问保存

在一个 CString 对象中的字符

Operator = 给 CString 对象赋一个新值

Operator + 连接两个字符串并返回一个新字符串

Operator += 把一个新字符串连接到一个已经存在的字符串的末端

Comparison

Operator == <, etc. 比较操作符（大小写敏感） Compare 比较两个字符串（大小写敏感） CompareNoCase 比较两个字符串（不区分大小写）

Collate 比较两个字符串（大小写敏感，使用现场特别信息）

CollateNoCase 比较两个字符串（不区分大小写，使用现场特别

信息）

M id	提取一个字符串的中间一部分（类似于	BASIC	的
	M ID$ 函数）
Left	提取一个字符串的左边一部分（类似于	BASIC	的
	LEFT$ 函数）
Right	提取一个字符串的右边一部分（类似于	BASIC	的
	RIGHT $ 函数）

SpanIncluding 提取一个字符串，该子字符串中仅含有某一字符

集合中的字符。

SpanExcluding 提取一个字符串，该子字符串中不含有某一字符

集合中的字符。

Othe r Conversion s MakeUpper 将字符串中的所有字符转换为大写字符

MakeLower 将字符串中的所有字符转换为小写字符

MakeReverse 将字符串中的字符以倒序排列

Replace 用其它字符替换指定的字符

Remove 从一个字符串中移走指定的字符

Insert 在字符串中的给定索引处插入一个字符或一个子字符串

Delete 从一个字符串中删除一个或多个字符

Format 像 sprintf 函数一样格式化该字符串

FormatV 像 vprintf 函数一样格式化该字符串

TrimLeft 将字符串中前面的空格整理出字符串

TrimRight 将字符串中结尾的空格整理出字符串

FormatMessage 格式化一个消息字符串

Searchin g Find 在一个较大的字符串中查找字符或子字符串ReverseFind 在一个较大的字符串中从末端开始查找某个字符FindOneOf 查找与某个字符集合中的字符相匹配的第一个字

符

Operator << 把一个 CString 对象插入一个存档或转储的环境中

Operator >> 从一个存档中提取一个 CString 对象

Buffer Access

GetBuffer 返回一个指向 CString 对象的指针

GetBufferSetLengt h

返回一个指向 CString 对象的指针，字符串被截断为指定的长度

ReleaseBuffer 释放对 GetBuffer 所返回的缓冲区的控制权

FreeExtra 通过释放原先为此字符串分配的额外内存来删除此字符串对象的额外开销

LockBuffer 使引用计数无效并保护缓冲区内的数据

UnlockBuffer 使引用计数有效并释放缓冲区中的数据

AllocSysString 由 CString 数据分配一个 BSTR

SetSysString 使用 CString 对象中的数据来设置一个已存在的

BSTR

LoadString 从一个 W indows 资源中加载一个已经存在的 CString

对象

AnsiToOem 实现由 ANSI 字符集到 OEM 字符集的对应转换

OemToAnsi 实现由 OEM 字符集到 ANSI 字符集的对应转换

成员函数

CString::AllocSysString

BSTR AllocSysString ( ) const; throw( CMemoryException );

返回值

指向新分配的字符串。

说明

此成员函数分配一个 BSTR 类型的新的 OLE 的兼容 Automation 字符串，并把包括空结束符在内的此 CString 对象的内容拷贝到其中，若内存不足，则发出CMemoryException 异常。这个函数通常是用来为 OLE 自动化返回字符串。

在很少的情况下，你需要使用 ::SysFreeString 来重新分配此函数返回的字符串的存储单元。

注意如果你使用的是一个共享库的 MFC 并且是在调试模式下生成的，则你必须与 MFCO42D.DLL 连接来获得这个函数。通过在 STDAFX.H 文件中

包括 <afxdisp.h> ，可以使连接程序自动获得 MFCO42D.DLL 。

有关 W indows 中的 OLE 分配函数的更多信息，参见 “ W in32 SDK OLE 程序员参考 ” 中的 ::SysAllocString 和 ::SysFreeString。

请参阅 ::SysAllocString, ::SysFreeString, CMemoryException

CString::Ans iT i Oem void AnsiToOem( ); 说明

此成员函数将 CString 对象中的所有字符由 ANSI 字符集转换为 OEM 字符集。参见 “ M icrosoft Visual C++6.0 参考库 ” 中的 “ Microsoft Visual C++6.0 语言参考 ” 卷中的 “ ANSI 字符代码表 ” 。

请参阅 CString::OemToAnsi

CString::Collate

int Collate( LPCTSTR lpsz ) const;

返回值

如果两个字符串是一样的，则返回非零值；如果 CString 对象小于 lpsz 则返回值 <0 ；如果此 CString 对象大于 lpsz 则返回值 >0 。

参数

lpsz

要用于比较的另一个字符串。

此成员函数通过使用通用文本函数 _tcscoll 来比较这个 CString 对象和另一个字符串。此通用文本函数 _tcscoll 是在 TCHAR.H 中定义的，根据在编译时设置的字符来与 strcoll ， wcscoll ，或 _mbscoll 对应。这些函数的每一个都根据当前使用的代码页来进行一次区分大小写的比较。更多的信息，参见“ M icrosoft Visual C++ 6.0 运行时库参考 ” 中的 strca t， wcsca t， _mbsca t。

请参阅 CString::Compare, CString::CompareNoCase

CString::CollateNoCase

int CollateNocase( LPCTSTR lpsz ) const;

如果字符串是一样的（不区分大小写）则返回非零值；如果 CString 对象小于 lpsz

（不区分大小写）则返回值 <0 ，如果 CString 对象大于 lpsz （不区分大小写）则返回值 >0 。

参数

lpsz

指向要用于比较的另一个字符串的指针。

说明

此成员函数通过使用通用文本函数 _tcscoll 来比较这个 CString 对象和另一个字符串。此通用文本函数 _tcscoll 是在 TCHAR.H 中定义的，根据在编译时设置的字符来与 stricoll ， wcsicoll，或 _mbsicoll 对应。这些函数的每一个都根据当前

使用的代码页来进行一次不区分大小写的比较。

请参阅 CString::Collate, CString::CompareNoCase, CString::Compare

CString::Compare

int Compare( LPCTSTR lpsz ) const;

返回值

如果字符串是一样的则返回非零值；如果 CString 对象小于 lpsz 则返回值 <0 ，如果 CString 对象大于 lpsz 则返回值 >0 。

参数

lpsz

要用于比较的另一个字符串。

说明

此成员函数通过使用通用文本函数 _tcscmp 来比较这个 CString 对象和另一个字符串。此通用文本函数 _tcscmp 是在 TCHAR.H 中定义的，根据在编译时设置的字符来与 strcm p， wcscm p，或 _mbscmp 对应。这些函数的每一个都根据当前使用的代码页来进行一次区分大小写的比较，而且不会被现场影响。更多的信息，参见“ Microsoft Visual C++ 6.0 运行库参考 ”中的 strcm p，wcscm p，_mbscm p。

示例

下面的例子说明了如何使用 CString::Compare 。

// CString::Compare 示例CString s1( "abc" ); CString s2( " abd " );

ASSERT( s1.Compare( s2 ) == -1 ); // 与另一个 CString 比较。

ASSERT( s1.Compare( " ab e" ) == -1 ); // 与 LPTSTR 字符串比较。

请参阅 CString::CompareNoCase ,CString::Collate,CString::CollateNoCase

CString::CompareNoCase

int CompareNoCase( LPCTSTR lpsz ) const;

返回值

如果字符串是一样的（不区分大小写）则返回非零值；如果 CString 对象小于 lpsz

（不区分大小写）则返回值 <0 ，如果 CString 对象大于 lpsz （不区分大小写）则返回值 >0 。

说明

此成员函数通过使用通用文本函数 _tcsicmp 来比较这个 CString 对象和另一个字符串。此通用文本函数 _tcsicmp 是在 TCHAR.H 中定义的，根据在编译时设

置的字符来与 _ stricm p ， _ wcsicm p，或 _mbsicmp 对应。这些函数的每一个都根据当前使用的代码页来进行一次区分大小写的比较，而且不会被现场影响。更多的信息，参见“ M icrosoft Visual C++ 6.0 运行库参考 ”中的 _stricm p，_wcsicm p，

_mbsicm p。

示例

下面的例子说明了如何使用 CString::CompareNoCase 。

// CString::CompareNoCase 示例

CString s1( "abc" ); CString s2( "ABD" );

ASSERT( s1.CompareNoCase( s2 ) == -1 ); // 与一个 CString 比较。

ASSERT( s1.Compare( "ABE" ) == -1 ); // 与 LPTSTR 字符串比较。

请参阅 CString::Compare, CString::Collate ,Cstring::CollateNoCase

CString::CString

CString( );

CString( const CString& stringSrc ); throw( CMemoryException );

CString( TCHAR ch, int nRepeat = 1 ); throw( CMemoryException );

CString( LPCTSTR lpch , int nLength ); throw( CMemoryException );

CString( const unsigned char* psz ); throw( CMemoryException );

CString( LPC W STR lpsz ); throw( CMemoryException );

CString( LPCSTR lpsz );

throw( CMemoryException );

参数

stringSrc

一个已经存在的 CString 对象，它要被拷贝到此 CString 对象中。

要被重复 nRepeat 次的单个字符。

nRepeat

要对 ch 重复的次数。

lpch

个指向字符数组的指针，该字符数组的长度是
nLength ，不包括结尾的

空字符。

nLength

pch 中的字符的个数。

psz

一个要被拷贝到此 CString 对象中去的以空字符结尾的字符串。

lpsz

个要被拷贝到此 CString 对象中去的以空字符结尾的字
符串。

说明

这些构造函数的每一个都用来以指定的数据初始化一个新的 CString 对象。

由于构造函数是将输入数据拷贝到新分配的存储区，所以你应该注意可能会导致的内存异常。注意，这些构造函数中的某些函数的作用相当于一个转换函数。这就允许你使用替换物，例如在一个需要 CString 对象的地方用一个 LPTSTR 来代替。

此构造函数的某几种形式具有特殊的目的：

CString( LPCSTR lpsz ) 从一个 ANSI 字符串构造一个 Unicode

CString。你可以象下面的例子那样用这个函数来加载一个字符串资源。
CString( LPC W STR lpsz ) 从一个 Unicode 字符串构造一个

CString。
CString( const unsigned char* psz ) 从一个指向 unsigned char

的指针构造一

个 CString 。

想了解更多的信息，请参阅 “ Visual C++ 程序员指南 ” 随机文中的“ String:CString Exception Cleanup ” 一节。

示例

下面的例子说明了如何使用 CString::CString。

// CString::CString 示例

CString s1; // 空字符串

CString s2( "cat" ); // 从一个文字的 C 字符串

CString s3 = s2; // 拷贝构造函数

CString s4( s2 + " " + s3 ); // 从一个字符串表达式

CString s5( 'x' ); // s5 = "x"

CString s6( 'x', 6 ); // s6 = "xxxxxx"

CString s7((LPCSTR)ID_FILE_NEW); // s7 = "Create a new document" CString city = "Philadelphia"; // 不是赋值操作符

请参阅 CString::operator =

CString::Delete

int Delete( int nIndex , int nCount = 1); throw( CMemoryException ) ;

返回值

返回已改变的字符串的长度。

参数

nIndex

要删除的第一个字符的索引。

nCoun t

要删除的字符数。

说明

此成员函数用来从一个字符串中从 nIndex 开始的地方删除一个或多个字符。如果 nCount 比此字符串还要长，则字符串的其余部分都将被删除。

示例

// 下面的例子说明了如何使用 CString::Delete 。

str2 = “ Hockey is best!” ;

printf( “ Before: %s\n, (LPCTSTR) str2 ); int n = str2.Delete(6, 3 );

printf( “ After: %s/n ” , (LPCTSTR) str2 ); ASSERT( n == str2.Getlength ( ) );

// 这些代码产生下面的删除行：

Before: Hockey is best!

After: Hockey best!

请参阅 CString::Insert

CString::Empty void Empty( ); 说明

此成员函数用来使 CString 对象成为一个空字符串，并释放相应的内存。

更多的信息，参见“ V isual C++ 程序员指南 ”中的“ 字符串： CString 异常清除 ”。

示例

下面的例子说明了如何使用 CString::Empty 。

// CString::Empty 示例

CString s( "abc" );

s.Empty();

ASSERT( s.GetLength( ) == 0 );

请参阅 CString::IsEmpty

CString::Find

int Find( TCHAR ch ) const;

int Find( LPCTSTR lpszSub ) const; int Find( TCHAR ch, int nStart ) const;

int Find( LPCTSTR lpszSub , int nStart ) const;

返回值

返回此 CString 对象中与需要的子字符串或字符匹配的第一个字符的从零开始的索引；如果没有找到子字符串或字符则返回 -1 。

参数

要搜索的单个字符。

lpszSub

要搜索的子字符串。

nStart

字符串中开始搜索的字符的索引，如果是 0 ，则是从头开始搜索。如果 nStart

不是 0 ，则位于 nStart 处的字符不包括在搜索之内。

pstr

指向要搜索的字符串的指针。

说明

此成员函数用来在此字符串中搜索子字符串的第一个匹配的字符。函数的重载可以接收单个字符（类似于运行时函数 strchr）和字符串（类似于 strstr ）。

示例

//下面演示第一个例子

// CString::Fin d（ TCHAR ch ） CString s( "abcdef" ); ASSERT( s.Find( 'c' ) == 2 );

ASSERT( s.Find( "de" ) == 3 );

// 下面演示第二个例子

// Cstring::Find(TCHAR ch,int nStart) Cstring str(“ The stars are aligned ” ); Ing n = str.Find( 'e ',5);

ASSERT(n == 12)

请参阅 CString::ReverseFind, CString::FindOneOf

CString::FindOneOf

int FindOneOf( LPCTSTR lpszCharSet ) const;

返回值

返回此字符串中第一个在 lpszCharSet 中也包括的字符的从零开始的索引。

参数

lpszCharSet

包含用于匹配字符的字符串。

说明

此成员函数在此字符串中搜索与 lpszCharSet 中任意字符匹配的第一个字符。

示例

下面的例子说明了如何使用 CString::FindOneO f。

// CString::FindOneOf 示例

CString s( "abcdef" );

ASSERT( s.FindOneOf( "xd" ) == 3 ); // 'd' is first match.

请参阅 CString::Find

CString::Format

void Format( LPCTSTR lpszFormat , ... ); void Format( UINT nFormatID, ... );

参数

lpszFormat

一个格式控制字符串。

nFormatID

包含格式控制字符串的字符串资源标识符。

说明

此成员函数用来将格式化数据写入一个 CString 中，其方法就像 sprintf 函数向一个 C -风格的字符数组中格式化输出数据一样。这个成员函数在 CString 中格式化并存储一系列字符和值。根据 lpszFormat 中指定的格式或 nFormatID 标识的字符串资源，函数中的每一个可选参数（如果有）都被转换并输出。

如果此字符串对象本身是作为 Format 的一个参数，则调用将失败。例如象下面的代码：

CString str = “ Some Data ” ;

str.Format( “ %s%d ” ,str, 123); //注意：在参数列表中也使用了 str 。

将导致不可预期的结果。

当你传递一个字符串作为一个可选择的参数时，你必须显式地将它转换为

LPCTSTR 。这个格式与 printf 函数中的格式参数具有相同的形式和函数。（有

关格式和参数的描述，参见“ Microsofr Visual C++ 6.0 运行库参考 ”中的 printf 。）在被写的字符串结尾将添加一个空字符。

更多的信息，参见 “ Microsofr Visual C++ 6.0 运行时库参考 ” 中的 sprintf 。

请参阅 CString::GetBuffer,CString::FormatV

CString::FormatV

void FormatV( LPCTSTR lpszFormat , va _list argList );

参数

lpszFormat

一个格式控制字符串。

argList

要传递的参数列表。

此成员函数用来将格式化数据和一个参数变量列表写入一个 CString 中，其方法就像 vsprintf 函数向一个 C - 风格的字符数组中格式化输出数据一样。这个成员函数在 CString 中格式化并存储一系列字符和值。根据 lpszFormat 中指定的格式，函数中的每一个可选参数都被转换并输出。

如果此字符串对象本身是作为 FormatV 的一个次数，则调用将失败。例如象下面的代码：

CString str = “ Some Data ” ;

str.FormatV(“ %s% d ” ,str, 123); //注意：在次数列表中也使用了 str。

将导致不可预期的结果。

更多的信息，参见 “ Microsoft V isual C++ 6.0 运行库参考 ” 中的 vsprintf 。

// 使用 CString::FormatV ，你可以像下面这样来编写函数：

void WriteLogEntry( CStdioFile& refFile, LPCTSTR pstrFormat, ... )

{

CTime timeWrite;

timeWrite = CTime:GetCurrentTime( );

// 输出时间

CString str = timeWrite.Format ( “ %d %b %y %H:%M:%S – ” ); refFile.Write( str, str.GetLength( ));

// 格式化并输出给定的数据

va_list args;

va_start( args, pstrFormat ); str.FormatV( pstrFormat, args ); refFile.Write( str, str.GetLength( ) );

// 插入一个换行符refFile.Write( “ \n ” , 1 ); return;

}

你可以用任意个数的参数来调用上面的函数，例如：

WriteLogEntry( fileLog , “ Program started ” ); WriteLogEntry( fileLog , “ Processed %d bytes ” 91341 );

WriteLogEntry( fileLog , “ %d error(s) found in %d line(s)” , 10, 1351 ); WriteLogEntry( fileLog , “ Program completed ” );

上面的例子将把输出添加到你的 fileLog 文件，就像下面给出的一样：

17 Apr 97 12:34:53 – Program started

17 Apr 97 12:34:59 – Processed 91341 bytes

17 Apr 97 12:35:22 – 10 error(s) found in 1351 line(s)

17 Apr 97 12:35:23 – Program completed

请参阅 CString::Format, va_start

CString::FormatMessage

void FormatMessage( LPCTSTR lpszForma t, ... ); void FormatMessage( UINT nFormatID , ... );

参数

lpszFormat

指向格式控制字符串。它将被扫描来进行插入，从而进行格式化。这个格式字符串类似于运行时函数 pritf-style 格式字符串，除了这个字符串允许参数可以按任意顺序插入。

nFormatID

包含还没有格式化的消息文本的字符串资源标识符。

说明

此成员函数用来格式化一个消息字符串。此函数需要一个消息定义作为输入。该消息定义是由 lpszFormat 决定的，或者是来自由 nFormatID 标识的字符串资源。函数将这个格式化的消息文本拷贝到 CString 中，如果需要的话就处理任何嵌入的插入顺序。

每一次插入都必须有相应的参数跟随 lpszFormat 或 nFormatID 参数。在消息文本中，为了动态格式化消息，要支持几个转义序列。有关这些转义序列的描述和它们的意义，参见 “ W in32 SDK 程序员参考 ” 中的 W indows::FormatMessage 函数。

请参阅 ::FormatMessage,CString::LoadString,CString::Format

CString::FreeExtra

void FreeExtra( );

说明

此成员函数用来释放原先被此字符串分配的但不再使用的额外的内存。这将减小此字符串的内存的额外开销。此函数按 GetLength 返回的准确长度来重新分配缓冲区。

CString::GetAt

TCHAR GetAt( int nIndex ) const;

返回值

返回一个包含字符串中的指定位置的字符串的 TCHAR 。

参数

nIndex

CString 对象中的某个字符的从零开始的索引。 nIndex 参数必须大于或等于 0 ，并小于 GetLength 函数的返回值。 Microsoft 基础类库的测试版验证 nIndex 的边界；但是发行版不验证。

说明

你可以把一个 CString 对象看作是一个字符数组。 GetAt 成员函数返回一个由一个索引号指定的单个字符。重载的下标（ []）是 GetAt 常用的代用符。

示例

下面的例子说明了如何使用 CString::GetA t。

// CString::GetAt 示例

CString s( "abcdef" ); ASSERT( s.GetAt(2) == 'c' );

请参阅 CString::GetAt, CString::GetLength, CString::operator []

CString::GetBuffer

LPTSTR GetBuffer( int nMinBufLength );

throw( CMemoryException );

返回值

一个指向对象的（以空字符结尾的）字符缓冲区的 LPTSTR 指针。

参数

nMinBufLength

字符缓冲区的以字符数表示的最小容量。这个值不包括一个结尾的空字符的空间。

说明

此成员函数返回一个指向 CString 对象的内部字符缓冲区的指针。返回的

LPTSTR 不是 const ，因此可以允许直接修改 CString 的内容。

如果你使用由 GetBuffer 返回的指针来改变字符串的内容，你必须在使用其它的 CString 成员函数之前调用 ReleaseBuffer 函数。

在调用 ReleaseBuffer 之后，由 GetBuffer 返回的地址也许就无效了，因为其它的 CString 操作可能会导致 CString 缓冲区被重新分配。如果你没有改变此CString 的长度，则缓冲区不会被重新分配。

当此 CString 对象被销毁时，其缓冲区内存将被自动释放。

注意，如果你自己知道字符串的长度，则你不应该添加结尾的空字符。但是，当你用 ReleaseBuffer 来释放该缓冲区时，你必须指定最后的字符串长度。如果你添加了结尾的空字符，你应该给 ReleaseBuffer 的长度参数传递 -1 ， ReleaseBuffer 将对该缓冲区执行 strlen 来确定它的长度。

示例

下面的例子说明了如何用 CString::GetBuffer。

// CString::GetBuffer 例子

CString s( "abcd" ); #ifdef _DEBUG

afxDump << "CString s " << s << "\n"; #endif

LPTSTR p = s.GetBuffer( 10 );

strcpy( p, "Hello" ); // 直接访问 CString 对象。

s.R eleaseBuffer( ); #ifdef _DEBUG

afxDump << "CString s " << s << "\n"; #endif

请参阅 CString::GetBufferSetLength, CString::ReleaseBuffer

CString::GetBufferSetLength

LPTSTR GetBufferSetLength( int nNewLength );

throw( CMemoryException );

返回值

返回一个指向对象的（以空字符结尾的）字符缓冲区的 LPTSTR 指针。

参数

nNewLength

此 CString 字符缓冲区的以字符数表示的精确容量。

说明

此成员函数返回一个指向 CString 对象的内部字符缓冲区的指针，如果需要的话，切断或增长缓冲区的长度以精确匹配由 nNewLength 指定的长度。返回的LPTSTR 不是 const ，因此可以允许直接修改 CString 的内容。

如果你使用由 GetBuffer 返回的指针来改变字符串的内容，你必须在使用其它的 CString 成员函数之前调用 ReleaseBuffer 函数。

当此 CString 对象被销毁时，其缓冲区内存将被自动释放。

有关引用计数的更多信息，参见下面的文章：

“ W in 32 SDK 程序员参考 ” 中的“ 通过引用计数来管理对

象的生命周期 ” 。
“ W in 32 SDK 程序员参考 ” 中的 “ 实现引用计数 ” 。
“ W in 32 SDK 程序员参考 ” 中的 “ 管理引用计数的规则 ”

。

请参阅 CString::GetBuffer, CString::ReleaseBuffer

CString::GetLength int GetLength( ) const; 返回值

返回字符串中的字节计数。

说明

此成员函数用来获取这个 CString 对象中的字节计数。这个计数不包括结尾的

空字符。

对于多字节字符集（ MBC S ）， GetLength 按每一个 8 位字符计数；即，在一个多字节字符中的开始和结尾字节被算作两个字节。

示例

下面的例子说明了如何使用 CString::GetLength 。

// CString::GetLength 示例

CString s( "abcdef" );

ASSERT( s.GetLength() == 6 );

请参阅 CString::IsEmpty

CString::Insert

int Insert( int nIndex , TCHAR ch ); throw( CMemoryException );

int Insert( int nIndex , LPCTSTR pstr ); throw( CMemoryException );

返回值

返回被改变的字符串的长度。

参数

nIndex

某个字符的索引，在这个字符的前面将要进行插入操作。

要插入的字符。

pstr

一个指向要被插入的子字符串的指针。

说明

此成员函数用来在字符串中的给定索引处插入一个单个字符或一个子字符串。nIndex 参数标识了将要被移走以给字符或子串空间的第一个字符。如果 nIndex 是零，则插入将方式在这个字符串之前。如果 nIndex 大于字符串的长度，则函数将把当前的字符串与由 ch 或 pstr 指定的新字符串连接起来。

示例

// 下面的例子说明了如何使用 CString::Insert 。CString str( “ HockeyB est ” );

int n = str.Insert( 6, “ is ” ); ASSERT( n == str.GetLength( ) );

printf( “ 1: %s\n ” , ( LPCTSTR ) str ); n = str.Insert( 6, ' ' );

ASSERT( n == str.GetLength( ) ); printf ( “ 2: %s\n ” , (LPCTSTR) STR );

n = str.Insert(555, ‘1 ’ );

ASSERT( n == str.GetLength ( ) ); printf ( “ 3: %s\n ” , ( LPCTSTR ) str );

// 上面的代码将产生下面这些输出行：

Hockeyis Best
Hockey is Best
Hockey is Best!

请参阅 CString::Delete, CString::operator +

CString::IsEmpty BOOL IsEmpty( ) const; 返回值

如果 CString 对象的长度为 0 ，则返回非零值；否则返回 0 。

说明

此成员函数用来测试一个 CString 对象是否是空的。

示例

下面的例子说明了如何使用 CString::IsEmpty。

// CString::IsEmpty 示例

CString s;

ASSERT( s.IsEmpty() );

请参阅 CString::GetLength

CString::Left

CString Left( int nCount ) const; throw( CMemoryException );

返回值

返回一个包含指定范围字符的拷贝的 CString 对象。注意，返回的 CString 对象可能是空的。

参数

nCount

要从这个 CString 对象中提取的字符数。

说明

此成员函数用来从此 CString 对象中提取最前面的 nCount 个字符，并返回被提取的子字符串的拷贝。如果 nCount 超过了字符串的长度，则整个字符串都被提取。 Left 类似与 Basic LEFT $函数（除了索引是从零开始的）。

对于多字节字符集（ MBC S ）， nCount 指的是每 8 位字符的个数，即，在一个

多字节字符中开始和结尾字节被算作两个字符。

示例

下面的例子说明了如何使用 CString::Left。

// CString::Left 示例

CString s( _T("abcdef") ); ASSERT( s.Left(2) == _T("ab") );

请参阅 CString:: M id, CString::Right

CString::LoadString

BOOL LoadString( UINT nID ); throw( CMemoryException );

返回值

如果加载资源成功则返回非零值；否则返回 0 。

参数

nID

一个 Windows 字符串资源 ID 。

说明

此成员函数用来读取一个由 nID 标识的 W indows 字符串资源，并放入一个已有的 CString 对象中。

示例

下面的例子说明了如何使用 CString::LoadString 。

// CString::LoadString 示例

#define IDS_FILENOTFOUND 1

CString s;

if (! s.LoadString( IDS_FILENOTFOUND ))

{

AfxMessageBox("Error Loading String: IDS_FILENOTFOUND");

...

}

CString::LockBuffer LPTSTR LockBuffer( ); 返回值

返回一个指向 CString 对象的指针，或者是一个以 NULL 结尾的字符串。

说明

此成员函数用来加锁缓冲区内的一个字符串。

通过调用 LockBuffer，可以创建一个字符串的拷贝，然后将引用计数设置为 -1 。当引用计数被设置为 -1 时，缓冲区中的字符串被认为是处于“ 加锁 ” 状态。当

该字符串处于加锁状态时，字符串被从两个方面得到保护：

没有其它的字符串能够获得对此加锁字符串中的数据

的引用，即使是该字符串被赋予了加锁字符串。
加锁字符串将不能引用其它的字符串，即使另一个字

符串被拷贝到该加锁字符串中。

通过加锁缓冲区中的字符串，可以保证该字符串对缓冲区的独占保持完整。

在你完成了对 LockBuffer 的使用之后，调用 UnlockBuffer 来将该引用计数恢复到 1 。

有关引用计数的更多信息，参见下面的文章：

“ W in 32 SDK 程序员参考 ” 中的“ 通过引用计数来管理对

象的生命周期 ” 。
“ W in 32 SDK 程序员参考 ” 中的 “ 实现引用计数 ” 。
“ W in 32 SDK 程序员参考 ” 中的 “ 管理引用计数的规则 ”

。

请参阅 CString::UnlockBuffer, CString::GetBuffer, CString::ReleaseBuffer

CString::MakeLower void MakeLower( ); 说明

此成员函数将此 CString 对象转换为一个小写字符串。

示例

下面的例子说明了如何使用 CString::MakeLowe r。

// CString::MakeLower 示例CString s( "ABC" ); s.MakeLower();

ASSERT( s == "abc" );

请参阅 CString:: M akeUpper

CString::MakeReverse

void MakeReverse( );

说明

此成员函数将此 CString 对象中的字符的顺序颠倒过来。

示例

下面的例子说明了如何使用 CString::MakeReverse 。

// CString::MakeReverse 示例

CString s( "abc" ); s.MakeReverse();

ASSERT( s == "cba" );

CString::MakeUpper

void MakeUpper( );

说明

此成员函数将此 CString 对象转换为一个大写字符串。

示例

下面的例子说明了如何使用 CString::MakeUpper。

// CString::MakeUpper 示例CString s( "abc" ); s.MakeUpper();

ASSERT( s == "ABC" );

请参阅 CString:: M akeLower

CString::Mid

CString Mid( int nFirst ) const; throw( CMemoryException );

CString Mid( int nFirst, int nCount ) const; throw( CMemoryException );

返回值

返回一个包含指定范围字符的拷贝的 CString 对象。注意，这个返回的 CString

对象可能是空的。

参数

nFirst

此 CString 对象中的要被提取的子串的第一个字符的从零开始的索引。

nCount

要从此 CString 对象中提取的字符数。如果没有提供这个参数，则字符串

的其余部分都被提取。

说明

此成员函数从此 CString 对象中提取一个长度为 nCount 个字符的子串，从 nFirst

（从零开始的索引）指定的位置开始。此函数返回一个对所提取的字符串的拷贝。 M id 类似于 Basic MID $函数（除了索引是从零开始的）。

对于多字节字符集（ MBC S ）， nCount 指的是每 8 位字符的数目；也就是说，在一个多字节字符中开始和结尾字节被算作两个字符。

示例

下面的例子说明了如果如何使用 CString:: M id 。

// CString::Mid 示例

CString s( _T("abcdef") );

ASSERT( s.Mid( 2, 3 ) == _T("cde") );

请参阅 CString::Left, CString::Right

CString::OemToAnsi

void OemToAnsi( );

说明

此成员函数将此 CString 对象中的所有字符由 OEM 字符集转换成 ANSI 字符集。参见 “ Microsoft Visual C++ 6.0 库参考 ” 中的 “ M icrosoft Visual C++ 6.0 语言参考手册 ” 卷中的 “ ANSI 字符代码表 ” 。

如果定义了 _UNICODE ，则这个函数是无效的。

请参阅 CString::AnsiToOem

CString::ReleaseBuffer

void ReleaseBuffer( int nNewLength = -1 );

参数

nNewLength

此字符串的以字符数表示的新长度，不计算结尾的空字符。如果这个字符串是以空字符结尾的，则参数的缺省值－ 1 将把 CString 的大小设置为字符串的当前长度。

说明

使用 ReleaseBuffer 来结束对由 GetBuffer 分配的缓冲区的使用。如果你知道缓冲区中的字符串是以空字符结尾的，则可以省略 nNewLength 参数。如果字符串不是以空字符结尾的，则可以使用 nNewLength 指定字符串的长度。在调用

ReleaseBuffer 或其它 CString 操作之后，由 GetBuffer 返回的地址是无效的。

示例

下面的例子说明了如何使用 CString::ReleaseBuffer。

// CString::ReleaseBuffer 示例

CString s; s = "abc";

LPTSTR p = s.GetBuffer( 1024 );

strcpy(p, "abc"); // 直接使用该缓冲区

ASSERT( s.GetLength() == 3 ); // 字符串长度 = 3 s.ReleaseBuffer(); // 释放多余的内存，现在 p 无效。ASSERT( s.GetLength() == 3 ); // 长度仍然是 3

请参阅 CString::GetBuffer

CString::Remove

int CString::Remove ( TCHAR ch );

返回值

返回从字符串中移走的字符数。如果字符串没有改变则返回零。

参数

要从一个字符串中移走的字符。

说明

此成员函数用来将 ch 实例从字符串中移走。与这个字符的比较是区分大小写的。

示例

// 从一个句子中移走小写字母 'c':

CString str ( “ This is a test .” ); int n = str.Remove( 't ' ); ASSERT( n == 2 );

ASSERT( str == “ This is a es. ” );

请参阅 CString::Replace

CString::Replace

int Replace( TCHAR chOld , TCHAR chNew );

int Replace( LPCTSTR lpszOld , LPCTSTR lp szNew );

返回值

返回被替换的字符数。如果这个字符串没有改变则返回零。

参数

chOld

要被 chNew 替换的字符。

chNew

要用来替换 chOld 的字符。

lpszOld

个指向字符串的指针，该字符串包含了要被 lpszNew
替换的字符。

lpszNew

个指向字符串的指针，该字符串包含了要用来替换
lpszOld 的字符。

说明

此成员函数用一个字符替换另一个字符。函数的第一个原形在字符串中用 chNew 现场替换 chOld 。函数的第二个原形用 lpszNew 指定的字符串替换 lpszOld 指定的子串。

在替换之后，该字符串有可能增长或缩短；那是因为 lpszNew 和 lp sz Old 的长度不需要是相等的。两种版本形式都进行区分大小写的匹配。

示例

// 第一个例子， old 和 new 具有相同的长度。

CString strZap( “ C - - ” );

int n = strZap.Replace( '- ', '+ ' ); ASSERT( n == 2 ); ASSERT(strZap == “ C++ ” );

// 第二个例子， old 和 new 具有不同的长度。

CString strBang( “ Everybody likes ice hockey ” ); n = strBang.Replace( “ hockey ” , “ golf ” ); ASSERT( n ==1 );

n = strBang.Replace ( “ likes ” , “ plays ” ); ASSERT( n == 1 );

n = strBang.Replace( “ ice” , NULL ); ASSERT( n == 1 );

ASSERT( strBang == “ Everybody plays golg ” );

// 注意，现在在你的句子中有了一个额外的空格。

// 要移走这个额外的空格，可以将它包括在要被替换的字符串中，例如， “ ice ”。

请参阅 CString::Remove

CString::ReverseFind

int ReverseFind( TCHAR ch ) const;

返回值

返回此 CString 对象中与要求的字符匹配的最后一个字符的索引；如果没有找到需要的字符则返回 -1 。

参数

要搜索的字符。

说明

此成员函数在此 CString 对象中搜索与一个子串匹配的最后一个字符。此函数

类似于运行时函数 strrchr。

示例

// CString::ReverseFind 示例

CString s( "abcabc" );

ASSERT( s.ReverseFind( 'b' ) == 4 );

请参阅 CString::Find, CString::FindOneOf

CString:: Right

CString Right( int nCount ) const; throw( CMemoryException );

返回值

返回一个包含指定字符拷贝的 CString 对象。注意，这个返回的 CString 对象可能是空的。

nCount

要从这个 CString 对象中提取的字符数目。

说明

此成员函数用来从此 CString 对象中提取最后（最右边）的 nCount 个字符，并返回此提取字符串的一个拷贝。如果 nCount 超过了字符串的长度，则提取整个字符串。 Right 类似于 Basic 的 RIGHT $ 函数（除了索引是从零开始的）。

对于多字节字符集（ MBC S ）， nCount 指的是每 8 位字符的数目；也就是说，在一个多字节字符中开始和结尾字节被算作两个字符。

下面的例子说明了如何使用 CString::Righ t。

// CString::Right 示例

CString s( _T("abcdef") ); ASSERT( s.Right(2) == _T("ef") );

请参阅 CString:: M id, CString::Left

CString:: SetAt

void SetAt( int nIndex , TCHAR ch );

参数

nIndex

CString 对象中的某个字符的从零开始的索引。 nIndex 参数必须大于或等于 0 ，小于由 Getlength 的返回的值。 M icrosoft 基础类库的测试版本将检

验 nIndex 的边界，而 Release 版本则不检验。

要插入的字符。

说明

你可以将一个 CString 对象看作是一个字符数组。 SetAt 成员函数重写由一个索引值指定的单个字符。如果索引超出了已有字符串的边界， SetAt 不会扩大这个字符串。

请参阅 CString::GetAt, CString::operator [ ]

CString:: SetSysString

BSTR SetSysString( BSTR* pbstr ) const;

返回值

返回新的字符串。

参数

pbstr

一个指向字符串的指针。

说明

此成员函数重新分配由 pbstr 所指向的 BSTR ，并将包括结尾的空字符在内的CString 对象中的内容拷贝到该 BSTR 中。由 pbstr 所引用的 BSTR 的值可能会发生变化。如果内存不足，此函数将抛出一个 CMemoryException 异常。

这个函数通常被用来为 OLE 自动化改变通过引用传递的字符串的值。

有关 W indows 中的 OLE 重分配函数的更多信息，参见 “ W in32 SDK OLE 程序员参考 ” 中的 ::SysReallocStringLen 和 ::SysFreeString 。

CString:: SpanExcluding

CString SpanExcluding( LPCTSTR lpszCharSet ) const; throw( CMemoryException );

返回值

返回一个子字符串，该子串保存了在 CString 字符串中但又不在 lpszCharSet 字符集合中的字符，该子串以字符串的第一个字符作为开始，以在此字符串中发现的第一个也在 lpszCharSet 字符集中字符前面的字符作为结尾（也就是说，从此字符串的第一个字符开始，直到第一个也包括在 lpszCharSet 字符集的字符为止，但不包括这个也在 lpszCharSet 字符集中的字符）。如果 CString 中的每一

个字符都不在 lpszCharSet 字符集合中，则返回整个字符串。

参数

lpszCharSet

一个被解释为字符集的字符串。

说明

此成员函数用来查找整个 CString 对象中的字符串，找出 lpszCharSet 指定的字符集中任何字符第一次出现的位置。 SpanExcluding 提取并返回这个 lpszCharSet 字符集中的字符第一次出现之前的所有字符（换句话说，来自 lpszCharSet 字符集的字符以及在它之后的字符串都不会被返回）。如果在此字符串中没有发现来自 lpszCharSet 字符集的字符，则 SpanExcluding 返回整个字符串。

下面的函数返回 src 参数的第一个部分。

// 由一个分号（；），一个逗号 ( , ) ，一个句号 ( . ) ，一个破折号 ( - )，

// 或一个冒号 ( : ) 划定界线的部分。

CString GetFirstPart( CString src)

{

return src.SpanExcluding( ";,.- :");

}

请参阅 CString::SpanIncluding

CString:: SpanIncluding

CString SpanIncluding( LPCTSTR lpszCharSet ) const; throw( CMemoryException );

返回此字符串中的一个子字符串，该子串中的字符也在 lpszCharSet 字符集中字符集中。该子串开始于字符串中的第一个字符，当发现第一个不是 lpszCharSet 字符集中的字符时结束。如果字符串中的第一个字符就不是指定字符集中的字符，则 SpanIncluding 返回一个空的子字符串。

参数

lpszCharSet

一个被解释为字符集的字符串。

说明

此成员函数用来从字符串中提取字符，提取的子字符串开始于字符串中的第一个字符，其字符都是由 lpszCharSet 指定的字符集中的。如果字符串的第一个字

个连续字符序列，它们都是该字符集中的字符。

示例

下面的例子说明了如何使用 CString::SpanIncluding。

// CString::SpanIncluding 示例

CString str( "cabbage" );

CString res = str.SpanIncluding( "abc" ); ASSERT( res == "cabba" );

res = str.SpanIncluding( "xyz" ); ASSERT( res.IsEmpty( ) );

请参阅 CString::SpanExcluding

CString:: TrimLeft

void TrimLeft( );

void CString:: TrimLeft( TCHAR chTarget );

参数

chTarget

要被整理的目标字符。

lpszTargets

指向一个字符串的指针，该字符串包含了要被整理的目标字符。

说明

这个成员函数的没有参数的版本用来将字符串最前面的空格修整掉。当在没有参数的情况下调用时， TrimLeft 删除换行符，空格和 tab 字符。

这个成员函数的需要参数的版本用来将一个特定的字符或一群特定的字符从字符串的开始处删除。

指南 ” 中的 “ 字符串主题 ” 。

请参阅 CString:: M id, CString::Left, CString::Right,

CString::MakeUpper, CString::MakeLower, CString::MakeReverse, CString::Format

CString:: TrimRight

void Trim Righ t( );

void CString:: Trim Right ( TCHAR chTarget ); void CString:: TrimRight( LPCTSTR lpszTargets );

参数

chTarget

要被整理的目标字符。

lpszTargets

说明

这个成员函数的没有参数的版本用来将字符串最后面的空格修整掉。当在没有参数的情况下调用时， Trim Right 从字符串中删除换行符，空格和 tab 字符。

这个成员函数的需要参数的版本用来将一个特定的字符或一群特定的字符从字符串的结尾处删除。

示例

CString strBefore;

CString strAfter;

strBefore = " Hockey is Best!!!! " ; strAfter = strBefore; str.TrimRight('!' );

printf ( " Before: \ " %s\" \n " ,(LPCTSTR) strBefore );

printf ( " After: \ " %s\ " \n " ,(LPCTSTR) strBefore );

strBefore = " Hockey is Best?!?!?!?!" ; strAfter = strBefore;

str.TrimRight( ‘ ?!’ );

printf ( " Before: \ " %s\" \n " ,(LPCTSTR) strBefore ); printf ( " After: \ " %s\" \n " ,(LPCTSTR) str After );

在上面的第一个例子中，字符串“ Hockey is Best!!!! ”变成了“ Hockey is Bes t” 。

在上面的第二个例子中，字符串 “ Hockey is Best?!?!?!?!” 变成了 “ Hockey is Best ”。

更多的信息，参见 “ Visual C++ 程序员指南 ” 中的 “ 字符串主题 ” 。

请参阅 CString::TrimLeft, CString::Mid, CString::Left, CString::Right, CString::MakeUpper,

CString::MakeLower, CString::MakeReverse, CString::Format

CString:: UnlockBuffer void UnlockBuffer( ); 说明

此成员函数用来解锁先前通过调用 LockBuffer 加锁的的缓冲区。 UnlockBuffer

将引用计数恢复为 1 。

CString 析构函数使用 UnlockBuffer 来保证当析构函数被调用时缓冲区不会被加锁。

请参阅 CString::LockBuffer, CString::GetBuffer, CString::ReleaseBuffer

操作符

CString::operator =

const CString& operator =( const CString& stringSrc ); throw( CMemoryException );

const CString& operator =( TCHAR ch ); throw( CMemoryException );

const CString& operator =( const unsigned char* psz );

throw( CMemoryException );

const CString& operator =( LPCWSTR lpsz ); throw( CMemoryException );

const CString& operator =( LPCSTR lpsz ); throw( CMemoryException );

说明

这个 CString 赋值操作符（ = ）用新的数据来初始化一个已经存在的 CString 对

象。如果目标字符串（即左边的字符串）已经具有足够大的空间来保存新数据，则不用进行新的内存分配。不管你什么时候使用这个赋值操作符，都要小心可能出现的内存异常，因为常常要为保存新的结果给 CString 对象分配内存。

示例

下面的例子说明了如何使用 CString::operator = 。

// CString::operator = 示例

CString s1, s2; // 空的 CString 对象

s1 = "cat" // s1 = "cat"

s2 = s1; // s1 and s2 each = "cat"

s1 = "the " + s1; // 或者是表达式

s1 = 'x'; // 或者只是单个的字符

请参阅 CString::CString

operator LPCTSTR ( ) const;

返回值

返回一个指向字符串的数据的字符指针。

说明

这个非常有用的强制操作符提供了一种非常有效的方法来访问存放在 CString 对象中的以空字符结尾的 C 字符串。此函数不拷贝字符而仅返回一个指针。如果你在获取指针之后修改此 CString 对象，则可能导致内存被重新分配，并使该指针无效。

friend CArchive& operator <<( CArchive& ar , const CString& string ); throw( CArchiveException );

friend CArchive& operator >>( CArchive& ar , CString& string ); throw( CArchiveException );

friend CDumpContext& operator <<( CDumpContext& dc, const CString& string );

说明

CString 插入操作符（ << ）支持向一个存档进行诊断转储和存储。提取操作符支持从一个文档中进行装入。

CDumpContext 操作符只有在 M icrosoft 基础类库的调试版中才有效。

示例

下面的例子说明了如何使用 CString::operator <<, >> 。

// CString::operator <<, >>示例

extern CArchive ar;

CString s( "abc" );

#ifdef _DEBUG

afxDump << s; // Prints the value (abc) afxDump << &s; // Prints the address

#endif

if( ar.IsLoading() ) ar >> s;

else

ar << s;

请参阅 CDumpContext

CString::operator +

friend CString operator +( const CString& string1 , const CString& string2 ); throw( CMemoryException );

friend CString operator +( const CString& string , TCHAR ch ); throw( CMemoryException );

friend CString operator +( TCHAR ch , const CString& string );

throw( CMemoryException );

friend CString operator +( const CString& string, LPCTSTR lpsz ); throw( CMemoryException );

friend CString operator +( LPCTSTR lpsz , const CString& string ); throw( CMemoryException );

返回值

返回一个 CString 对象，该对象是此连接操作的临时结果。这个返回值使得在一个表达式中组合多次连接成为可能。

参数

string， string1 ， string2

要连接的 CString 对象。

将被连接到一个字符串之后的或将在其后连接一个字符串的字符。

lpsz

指向一个以空字符结尾的字符串的指针。

说明

此 + 操作符将两个字符串连接起来并返回一个 CString 对象。两个参数中的一个必须是一个 CString 对象，而另一个可以是指向字符的指针或是一个字符。不管你什么时候使用这个连接操作符，都要小心可能出现的内存异常，因为为了保存这个临时结果常常要分配新内存。

示例

下面的例子说明了如何使用 CString::operator + 。

// CString::operator + 示例CString s1( "abc" ); CString s2( "def" );

ASSERT( (s1 + s2 ) == "abcdef" ); CString s3;

s3 = CString( "abc" ) + "def" ; // Correct s3 = "abc" + "def";

// 错了！第一个参数必须是一个 CString 。

请参阅 CString::operator +=

CString::oeprator +=

const CString& operator +=( const CString& string ); throw( CMemoryException );

const CString& operator +=( TCHAR ch ); throw( CMemoryException );

const CString& operator +=( LPCTSTR lpsz ); throw( CMemoryException );

参数

string

将连接到此字符串之后的 CString 对象。

将连接到此字符串之后的一个字符。

lpsz

指向将连接到此字符串之后的的字符串的指针。

说明

此 += 连接操作符将字符连接到此 CString 字符串之后。 += 操作符可以接受另一个 CString 对象，一个指向字符的指针或一个字符作为参数。不管你什么时候使用这个连接操作符，都要小心可能出现的内存异常，因为常常要为添加到这个 CString 对象的字符分配内存。

示例

下面的例子说明了如何使用 CString::operator += 。

// CString::operator += 示例

CString s( "abc" );

ASSERT( ( s += "def" ) == "abcdef" );

请参阅 CString::operator +

CString Comparison Operators

BOOL operator ==( const CString& s1 , const CString& s2 ); BOOL operator ==( const CString& s1 , LPCTSTR s2 ); BOOL operator ==( LPCTSTR s1 , const CString& s2 ); BOOL operator !=( const CString& s1 , const CString& s2 ); BOOL operator !=( const CString& s1 , LPCTSTR s2 ); BOOL operator !=( LPCTSTR s1 , const CString& s2 ); BOOL operator <( const CString& s1 , const CString& s2 ); BOOL operator <( const CString& s1 , LPCTSTR s2 ); BOOL operator <( LPCTSTR s1 , const CString& s2 ); BOOL operator >( const CString& s1 , const CString& s2 ); BOOL operator >( const CString& s1 , LPCTSTR s2 ); BOOL operator >( LPCTSTR s1 , const CString& s2 ); BOOL operator <=( const CString& s1 , const CString& s2 ); BOOL operator <=( const CString& s1 , LPCTSTR s2 );

BOOL operator <=( LPCTSTR s1 , const CString& s2 ); BOOL operator >=( const CString& s1 , const CString& s2 ); BOOL operator >=( const CString& s1 , LPCTSTR s2 ); BOOL operator >=( LPCTSTR s1 , const CString& s2 );

返回值

如果字符串满足比较条件则返回非零值；否则返回 0 。

参数

s1, s2

要比较的 CString 对象。

说明

这些比较操作符用来比较两个字符串。它们是区分大小写的 Compare 成员函数的方便的代用符。

// CString 比较操作符示例

CString s1( "abc" ); CString s2( "abd" );

ASSERT( s1 < s2 ); // Operator is overloaded for both. ASSERT( "ABC" < s1 ); // CString and char* ASSERT( s2 > "abe" );

CString::operator [ ]

TCHAR operator []( int nIndex ) const;

参数

nIndex

字符串中的一个字符的从零开始的索引。

你可以将一个 CString 对象看作是一个字符数组。此重载下标操作符（ []）返回由 nIndex 中的从零开始的索引值指定的一个字符。此操作符是 GetAt 成员函数的惯用的代用符。

示例

下面的例子说明了如何使用 CString::operator [ ] 操作符。

// CString::operator [ ] 示例

CString s( "abc" );

ASSERT( s[1] == 'b' );

请参阅 CString::GetAt, CString::SetAt

C S tring

C S tring

C String 类 成 员

成 员 函 数

操 作 符

C String 类成员

成员函数

操作符