1.CString::IsEmpty
BOOL IsEmpty( ) const;
返回值：如果CString 對象的長度爲0，則返回非零值；否則返回0。
說明：此成員函數用來測試一個CString 對象是否是空的。
示例：
下面的例子說明了如何使用CString::IsEmpty。
// CString::IsEmpty 示例
CString s;
ASSERT( s.IsEmpty() );
請參閱 CString::GetLength
2.CString::Left
CString Left( int nCount ) const;
throw( CMemoryException );
返回值：返回的字符串是前nCount個字符。
示例：
CString s( _T("abcdef") );
ASSERT( s.Left(2) == _T("ab") );
3.CString::LoadString
BOOL LoadString( UINT nID );
throw( CMemoryException );
返回值：如果加載資源成功則返回非零值；否則返回0。
nID 一個Windows 字符串資源ID。
說明： 此成員函數用來讀取一個由nID 標識的Windows 字符串資源，並放入一個已有CString 對象中。
示例：
下面的例子說明了如何使用CString::LoadString。
// CString::LoadString 示例
#define IDS_FILENOTFOUND 1
CString s;
if (! s.LoadString( IDS_FILENOTFOUND ))
4.CString::MakeLower
void MakeLower( ); //改變字符的小寫
5.CString::MakeReverse
void MakeReverse( ); //字符倒置
6.CString::MakeUpper
void MakeUpper( ); //改變字符的大寫
7.CString::Mid
CString Mid( int nFirst ) const;
CString Mid( int nFirst, int nCount ) const;
nCount代表要提取的字符數, nFirst代表要提取的開始索引位置
示例：
CString s( _T("abcdef") );
ASSERT( s.Mid( 2, 3 ) == _T("cde") );
8.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
9.CString::Remove
int CString::Remove ( TCHAR ch );
返回值:返回從字符串中移走的字符數。如果字符串沒有改變則返回零。
參數:ch 要從一個字符串中移走的字符。
說明:此成員函數用來將ch 實例從字符串中移走。與這個字符的比較是區分大小寫
的。
示例:
// 從一個句子中移走小寫字母'c':
CString str (“This is a test.”);
int n = str.Remove( 't' );
ASSERT( n == 2 );
ASSERT( str ==“This is a es. ” );
10.CString::Replace
int Replace( TCHAR chOld, TCHAR chNew );
int Replace( LPCTSTR lpszOld, LPCTSTR lpszNew );
返回值:返回被替換的字符數。如果這個字符串沒有改變則返回零。
參數:chOld 要被chNew 替換的字符。
chNew 要用來替換chOld 的字符。
lpszOld 一個指向字符串的指針，該字符串包含了要被lpszNew 替換的字符。
LpszNew 一個指向字符串的指針，該字符串包含了要用來替換lpszOld 的字符。
說明:此成員函數用一個字符替換另一個字符。函數的第一個原形在字符串中用chNew
現場替換chOld。函數的第二個原形用lpszNew 指定的字符串替換lpszOld 指定
的子串。
在替換之後，該字符串有可能增長或縮短；那是因爲lpszNew 和lpszOld 的長度
不需要是相等的。兩種版本形式都進行區分大小寫的匹配。
示例:
// 第一個例子，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 ”。
11.CString::ReverseFind
int ReverseFind( TCHAR ch ) const;
返回值: 返回此CString 對象中與要求的字符匹配的最後一個字符的索引；如果沒有找
到需要的字符則返回-1。
參數: ch 要搜索的字符。
說明:此成員函數在此CString 對象中搜索與一個子串匹配的最後一個字符。此函數
類似於運行時函數strrchr。
示例:
// CString::ReverseFind 示例
CString s( "abcabc" );
ASSERT( s.ReverseFind( 'b' ) == 4 );
12.CString::Right
CString Right( int nCount ) const;
throw( CMemoryException );
返回值： 返回的字符串是最後nCount個字符。
CString s( _T("abcdef") );
ASSERT( s.Right(2) == _T("ef") );
13.CString:: SetAt
void SetAt( int nIndex, TCHAR ch );
說明：可以把字符串理解爲一個數組，SetAt類似於[].注意nIndex的範圍，如果不合適會有調試錯誤。 Ch 更替字符, 把nIndex位置上的字符 變成ch
示例：
CString s( "abc" );
s.MakeReverse();
ASSERT( s == "cba" );
14.CString::TrimLeft
void TrimLeft( );
void CString::TrimLeft( TCHAR chTarget );
說明：如果沒有參數,從左刪除字符(\n\t空格等),至到遇到一個非此類字符. 當然你也可以指定刪除那些字符. 如果指定的參數是字符串,那麼遇上其中的一個字符就刪除.
\n 換行符
\t TAB字符
示例1：
CString str = "\n\t a";
str.TrimLeft();
str爲“a”;
示例2：
CString str = "abbcadbabcadb ";
str.TrimLeft("ab");
結果"cadbabcadb "
str.TrimLeft("ac");
結果"bcadbabcadb "
15.CString::TrimRight
void TrimRight( );
void CString::TrimRight( TCHAR chTarget );
void CString::TrimRight( LPCTSTR lpszTargets );
說明：用法類似於上面。
16.CString::Compare
int Compare( LPCTSTR lpsz ) const;
返回值：字符串一樣返回0,小於lpsz 返回-1,大於lpsz 返回1, 區分大小字符
示例：
CString s1( "abc" );
CString s2( "abd" );
ASSERT( s1.Compare( s2 ) == -1 );
ASSERT( s1.Compare( "abe" ) == -1
17.CString::CompareNoCase
int CompareNoCase( LPCTSTR lpsz ) const;
返回值： 字符串一樣 返回0，小於lpsz 返回-1，大於lpsz 返回1，不區分大小字符
18.CString::Collate
int Collate( LPCTSTR lpsz ) const;
同CString::Compare
19.CString::CollateNoCase
int CollateNocase( LPCTSTR lpsz ) const;
同CString::CompareNoCase
20.CString::CString //構造函數
CString( );
CString( const CString& stringSrc );
CString( TCHAR ch, int nRepeat = 1 );
CString( LPCTSTR lpch, int nLength );
CString( const unsigned char* psz );
CString( LPCWSTR lpsz );
CString( LPCSTR lpsz );
示例：
CString s1;
CString s2( "cat" );
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";
21.CString::Delete
int Delete( int nIndex, int nCount = 1);
返回值:是被刪除前的字符串的長度
nIndex是第一個被刪除的字符，nCount是一次刪除幾個字符。根據我實驗得出的結果：當nCount>要刪除字符串的最大長度(GetCount() - nIndex)時會出錯，當nCount過大，沒有足夠的字符刪除時，此函數不執行。
示例：
CString str1,str2,str3;
char a;
str1 = "nihao";
str2 = "nIhao";
int x;
// int i=(str1 == str2);
str1.Delete(2,3);
如果nCount(3) > GetCount() – nIndex (5-2)就會執行錯誤
22.CString::Empty
Void Empty( );
返回值：沒有返回值 清空操作;
示例：
CString s( "abc" );
s.Empty();
ASSERT( s.GetLength( ) == 0 );
23.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;
返回值: 不匹配的話返回 -1; 索引以0 開始; nStar 代表以索引值nStart 的字符開始搜索 ,
即爲包含以索引nStart字符後的字符串.
示例：
CString s( "abcdef" );
ASSERT( s.Find( 'c' ) == 2 );
ASSERT( s.Find( "de" ) == 3 );
Cstring str(“The stars are aligned”);
Ing n = str.Find('e',5);
ASSERT(n == 12)
24.CString::FindOneOf
int FindOneOf( LPCTSTR lpszCharSet ) const;
返回值: 不匹配的話返回 -1; 索引以0 開始
注意::返回此字符串中第一個在lpszCharSet中也包括字符並且從零開始的索引值
示例：
CString s( "abcdef" );
ASSERT( s.FindOneOf( "xd" ) == 3 ); // 'd' is first match.
25.CString::Format
void Format( LPCTSTR lpszFormat, ... );
void Format( UINT nFormatID, ... );
參數：lpszFormat 一個格式控制字符串
nFormatID 字符串標識符
示例：
CString str;
Str.Format(“%d”,13);
此時Str爲13
26.CString::GetAt
TCHAR GetAt( int nIndex ) const;
返回值：返回標號爲nIndex的字符，你可以把字符串理解爲一個數組，GetAt類似於[].注意nIndex的範圍，如果不合適會有調試錯誤。
27.CString::GetBuffer
LPTSTR GetBuffer( int nMinBufLength );
返回值：一個指向對象的（以空字符結尾的）字符緩衝區的LPTSTR 指針。
參數：nMinBufLength
字符緩衝區的以字符數表示的最小容量。這個值不包括一個結尾的空字符的空間。
說明：此成員函數返回一個指向CString 對象的內部字符緩衝區的指針。返回的LPTSTR 不是const，因此可以允許直接修改CString 的內容。如果你使用由GetBuffer 返回的指針來改變字符串的內容，你必須在使用其它的CString 成員函數之前調用ReleaseBuffer 函數。
在調用ReleaseBuffer 之後，由GetBuffer 返回的地址也許就無效了，因爲其它的CString 操作可能會導致CString 緩衝區被重新分配。如果你沒有改變此CString 的長度，則緩衝區不會被重新分配。當此CString 對象被銷燬時，其緩衝區內存將被自動釋放。
注意：如果你自己知道字符串的長度，則你不應該添加結尾的空字符。但是，當你用ReleaseBuffer 來釋放該緩衝區時，你必須指定最後的字符串長度。如果你添加了結尾的空字符，你應該給ReleaseBuffer 的長度參數傳遞-1 ，ReleaseBuffer 將對該緩衝區執行strlen 來確定它的長度。
示例：
// CString::GetBuffer 例子
CString s( "abcd" );
#ifdef _DEBUG
afxDump << "CString s " << s << "\n";
#endif
LPTSTR p = s.GetBuffer( 10 );
strcpy( p, "Hello" ); // 直接訪問CString 對象。
s.ReleaseBuffer( );
#ifdef _DEBUG
afxDump << "CString s " << s << "\n";
#endif
28.CString::GetLength
int GetLength( ) const;
返回值:返回字符串中的字節計數。
說明:此成員函數用來獲取這個CString 對象中的字節計數。這個計數不包括結尾的空字符。
對於多字節字符集（MBCS），GetLength 按每一個8 位字符計數；即，在一個多字節字符中的開始和結尾字節被算作兩個字節。
示例
下面的例子說明了如何使用CString::GetLength。
// CString::GetLength 示例
CString s( "abcdef" );
ASSERT( s.GetLength() == 6 );
29.CString::Insert
int Insert( int nIndex, TCHAR ch );
int Insert( int nIndex, LPCTSTR pstr );
返回值：返回修改後的長度，nIndex是字符（或字符串）插入後的索引號例子
示例：
CString str( “HockeyBest”);
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 );
輸出
1. Hockeyis Best
2. Hockey is Best
3. Hockey is Best!
string == LPCSTR;
char * == LPTSTR;
CString/string 區別及其轉化
利用MFC進行編程時，我們從對話框中利用GetWindowText得到的字符串是CString類型，CString是屬於MFC的類。而一些標準C/C++庫函數是不能直接對CString類型進行操作的，所以我們經常遇到將CString類型轉化char*等等其他數據類型的情況。這裏總結備忘於此！
首先要明確，標準C中是不存在string類型的，string是標準C++擴充字符串操作的一個類。但是我們知道標準C中有string.h這個頭文件，這裏要區分清楚，此string非彼string。string.h這個頭文件中定義了一些我們經常用到的操作字符串的函數，如：strcpy、strcat、strcmp等等，但是這些函數的操作對象都是char*指向的字符串。 而C++的string類操作對象是string類型字符串，該類重裝了一些運算符，添加了一些字符串操作成員函數，使得操作字符串更加方便。有的時候我們要將string串和char*串配合使用，所以也會涉及到這兩個類型的轉化問題。
1.CString和string的轉化
stringstr="ksarea";
CStringcstr(str.c_str());//或者CString cstr(str.data());初始化時纔行
cstr=str.c_str();或者cstr=str.data();
str=cstr.GetBuffer(0); //CString -> string
cstr.format("%s", str.c_str()); //string->CString
cstr.format("%s", str.data()); //string->CString
str = LPCSTR(cstr); //CString->string
/*c_str()和data()區別是：前者返回帶'/0'的字符串，後者則返回不帶'/0'的字符串*/
2.CString和int的轉換
inti=123;
CStringstr;
str.format("%d",i);//int->CString 其他的基本類型轉化類似
i=atoi(str);//CString->int 還有(atof,atol)
3.char*和CString的轉換
CStringcstr="ksarea";
char* ptemp=cstr.getbuffer(0);
char* str;
strcpy(str,ptemp);//CString->char*
cstr.releasebuffer(-1);
char*str="lovesha";
CStringcstr=str;//char*->CString string類型不能直接賦值給CString
至於int與float、string與char*之間的轉化可以使用強制轉化，或者標準庫函數進行。對於CString與其他類型的轉化方法很多，但其實都殊途同歸，朝着一個方向即將類型首先轉化爲char*類型，因爲char*是不同類型之間的橋樑。得到char*類型，轉化爲其他類型就非常容易了
LPTSTR、LPCSTR、LPCTSTR、LPSTR的來源及意義
UNICODE：它是用兩個字節表示一個字符的方法。比如字符'A'在ASCII下面是一個字符，可'A'在UNICODE下面是兩個字符,高字符用0填充，而且漢字'程'在ASCII下面是兩個字節，而在UNICODE下仍舊是兩個字節
。UNICODE的用處就是定長表示世界文字，據統計，用兩個字節可以編碼現存的所有文字而沒有二義。
MBCS，它是多字節字符集，它是不定長表示世界文字的編碼。MBCS表示英文字母時就和ASCII一樣（這也是我們容易把MBCS和ASCII搞混的原因），但表示其他文字時就需要用多字節。
WINDOWS下面的程序設計可以支持MBCS和UNICODE兩種編碼的字符串，具體用那種就看你定義了MBCS宏還是UNICODE宏。MBCS宏對應的字符串指針是char*也就是LPSTR，UNICODE對應的指針是unsigned short*也就是LPWSTR，爲了寫程序方便微軟定義了類型LPTSTR，在MBCS下他就是char*, 在UNICODE下它是unsigned char*,這樣你就可以重定義一個宏進行不同字符集的轉換了。
LPTSTR、LPCSTR、LPCTSTR、LPSTR的意義：
LPSTR：32bit指針 指向一個字符串，每個字符佔1字節
LPCSTR:32-bit指針 指向一個常字符串，每個字符佔1字節
LPCTSTR:32-bit指針 指向一個常字符串,每字符可能佔1字節或2字節，取決於Unicode是否定義
LPTSTR:32-bit指針 每字符可能佔1字節或2字節，取決於Unicode是否定義
Windows使用兩種字符集ANSI和UNICODE，前者就是通常使用的單字節方式，但這種方式處理象中文這樣的雙字節字符不方便，容易出現半個漢字的情況。而後者是雙字節方式，方便處理雙字節字符。
WindowsNT的所有與字符有關的函數都提供兩種方式的版本，而Windows9x只支持ANSI方式。_T一般同字常數相關，如_T("Hello"。如果你編譯一個程序爲ANSI方式，_T實際不起任何作用。而如果編譯一個程序爲UNICODE方式，則編譯器會把"Hello"字符串以UNICODE方式保存。_T和_L的區別在於，_L不管你是以什麼方式編譯，一律UNICODE方式保存.
Windows核心編程的第一章。
L是表示字符串資源爲Unicode的。
比如
1
wchar_t Str[] = L"Hello World!";
這個就是雙子節存儲字符了。
_T是一個適配的宏～
當
#ifdef _UNICODE的時候
_T就是L
沒有#ifdef _UNICODE的時候
_T就是ANSI的。
比如
1
LPTSTR lpStr = new TCHAR[32];
2
TCHAR* szBuf = _T("Hello");
以上兩句使得無論是在UNICODE編譯條件下都是正確編譯的。
而且MS推薦你使用相匹配的字符串函數。
比如處理LPTSTR或者LPCTSTR 的時候，不要用strlen ,而是要用_tcslen
否則在UNICODE的編譯條件下，strlen不能處理 wchar_t*的字符串。
T是非常有意思的一個符號（TCHAR、LPCTSTR、LPTSTR、_T()、_TEXT()...），它表示使用一種中間類型，既不明確表示使用 MBCS，也不明確表示使用 UNICODE。那到底使用哪種字符集?編譯的時候才決定
在vc++中有着各種字符串的表示法，如您所說。
首先char* 是指向ANSI字符數組的指針，其中每個字符佔據8位（有效數據是除掉最高位的其他7位），這裏保持了與傳統的C,C++的兼容。
LP的含義是長指針(long pointer)。
LPSTR是一個指向以‘\0’結尾的ANSI字符數組的指針，與char*可以互換使用，在win32中較多地使用LPSTR。而LPCSTR中增加的‘C’的含義是“CONSTANT”（常量），表明這種數據類型的實例不能被使用它的API函數改變，除此之外，它與LPSTR是等同的。
爲了滿足程序代碼國際化的需要，業界推出了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類型的，它提供了一個封裝好的類供用戶方便地使用。
如果您還需要進一步的信息，請參看http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt_data_type_mappings.asp等其他有關信息。
LPTSTR、LPCSTR、LPCTSTR、LPSTR之間的轉換：
如何理解LPCTSTR類型？
2007-11-10 21:43
L表示long指針
這是爲了兼容Windows 3.1等16位操作系統遺留下來的，在win32中以及其他的32爲操作系統中， long指針和near指針及far修飾符都是爲了兼容的作用。沒有實際意義。
P表示這是一個指針
C表示是一個常量
T表示在Win32環境中， 有一個_T宏
這個宏用來表示你的字符是否使用UNICODE, 如果你的程序定義了UNICODE或者其他相關的宏，那麼這個字符或者字符串將被作爲UNICODE字符串，否則就是標準的ANSI字符串。
STR表示這個變量是一個字符串
所以LPCTSTR就表示一個指向常固定地址的可以根據一些宏定義改變語義的字符串。
同樣， 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 基本可以通用。
但是 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
CString 轉LPCTSTR:
2
CString cStr;
3
const char *lpctStr=(LPCTSTR)cStr;
4
5
LPCTSTR轉CString:
6
LPCTSTR lpctStr;
7
CString cStr=lpctStr;
如果你需要修改 CString 中的內容，它有一個特殊的方法可以使用，那就是 GetBuffer，它的作用是返回一個可寫的緩衝指針。 如果你只是打算修改字符或者截短字符串，你完全可以這樣做：
CString s(_T(\"File.ext\"));
LPTSTR p = s.GetBuffer();
LPTSTR dot = strchr(p, \'\'.\'\'); // OK, should have used s.Find...
if(p != NULL)
*p = _T(\'\'\\0\'\');
s.ReleaseBuffer();
這是 GetBuffer 的第一種用法，也是最簡單的一種，不用給它傳遞參數，它使用默認值 0，意思是：“給我這個字符串的指針，我保證不加長它”。當你調用 ReleaseBuffer 時，字符串的實際長度會被重新計算，然後存入 CString 對象中。
必須強調一點，在 GetBuffer 和 ReleaseBuffer 之間這個範圍，一定不能使用你要操作的這個緩衝的 CString 對象的任何方法。因爲 ReleaseBuffer 被調用之前，該 CString 對象的完整性得不到保障。研究以下代碼：
CString s(...);
LPTSTR p = s.GetBuffer();
//... 這個指針 p 發生了很多事情
int n = s.GetLength(); // 很糟D!!!!! 有可能給出錯誤的答案!!!
s.TrimRight(); // 很糟!!!!! 不能保證能正常工作!!!!
s.ReleaseBuffer(); // 現在應該 OK
int m = s.GetLength(); // 這個結果可以保證是正確的。
s.TrimRight(); // 將正常工作。
假設你想增加字符串的長度，你首先要知道這個字符串可能會有多長，好比是聲明字符串數組的時候用：
char buffer[1024];
表示 1024 個字符空間足以讓你做任何想做得事情。在 CString 中與之意義相等的表示法：
LPTSTR p = s.GetBuffer(1024);
調用這個函數後，你不僅獲得了字符串緩衝區的指針，而且同時還獲得了長度至少爲 1024 個字符的空間（注意，我說的是“字符”，而不是“字節”，因爲 CString 是以隱含方式感知 Unicode 的）。
同時，還應該注意的是，如果你有一個常量串指針，這個串本身的值被存儲在只讀內存中，如果試圖存儲它，即使你已經調用了 GetBuffer ，並獲得一個只讀內存的指針，存入操作會失敗，並報告存取錯誤。我沒有在 CString 上證明這一點，但我看到過大把的 C 程序員經常犯這個錯誤。
C 程序員有一個通病是分配一個固定長度的緩衝，對它進行 sprintf 操作，然後將它賦值給一個 CString：
char buffer[256];
sprintf(buffer, \"%......\", args, ...); // ... 部分省略許多細節
CString s = buffer;
雖然更好的形式可以這麼做：
CString s;
s.Format(_T(\"%....\"), args, ...);
如果你的字符串長度萬一超過 256 個字符的時候，不會破壞堆棧。
另外一個常見的錯誤是：既然固定大小的內存不工作，那麼就採用動態分配字節，這種做法弊端更大：
int len = lstrlen(parm1) + 13 lstrlen(parm2) + 10 + 100;
char * buffer = new char[len];
sprintf(buffer, \"%s is equal to %s, valid data\", parm1, parm2);
CString s = buffer;
......
delete [] buffer;
它可以能被簡單地寫成：
CString s;
s.Format(_T(\"%s is equal to %s, valid data\"), parm1, parm2);
需要注意 sprintf 例子都不是 Unicode 就緒的，儘管你可以使用 tsprintf 以及用 _T() 來包圍格式化字符串，但是基本 思路仍然是在走彎路，這這樣很容易出錯。