C++字符串完全指引之二 —— 字符串封裝類


原著：Michael Dunn

作者：Chengjie Sun

原文出處：CodeProject：The Complete Guide to C++ Strings, Part II


引言

　　因?yàn)镃語言風(fēng)格的字符串容易出錯(cuò)且不易管理，黑客們甚至利用可能存在的緩沖區(qū)溢出bug把C語言風(fēng)格的字符串作為攻擊目標(biāo)，所以出現(xiàn)了很多字符串封裝類。不幸的是，在某些場合下我們不知道該使用哪個(gè)字符串類，也不知道怎樣把一個(gè)C風(fēng)格的字符串轉(zhuǎn)換成一個(gè)字符串封裝類。
　　這篇文章將介紹所有在Win32 API, MFC, STL, WTL 和 Visual C++ 運(yùn)行庫中出現(xiàn)的字符串類型。我將描述每一個(gè)類的用法，告訴大家怎樣創(chuàng)建每一個(gè)類的對象以及怎樣把一個(gè)類轉(zhuǎn)換成其他類。受控字符串和Visual C++ 7中的類兩部分是Nish完成的。
　　為了更好的從這篇文章中受益，你必須要明白不同的字符類型和編碼，這些內(nèi)容我在第一部分中介紹過。

Rule #1 of string classes

　　使用cast來實(shí)現(xiàn)類型轉(zhuǎn)換是不好的做法，除非有文檔明確指出這種轉(zhuǎn)換可以使用。
促使我寫這兩篇文章的原因是字符串類型轉(zhuǎn)換中經(jīng)常遇到的一些問題。當(dāng)我們使用cast把字符串從類型X轉(zhuǎn)換到類型Z的時(shí)候，我們不知道為什么代碼不能正常工作。各種各樣的字符串類型，尤其是BSTR，幾乎沒有在任何一個(gè)地方的文檔中被明確的指出可以用cast來實(shí)現(xiàn)類型轉(zhuǎn)換。所以我想一些人可能會(huì)使用cast來實(shí)現(xiàn)類型轉(zhuǎn)換并希望這種轉(zhuǎn)換能夠正常工作。
　　除非源字符串是一個(gè)被明確指明支持轉(zhuǎn)換操作符的字符串包裝類，否則cast不對字符串做任何轉(zhuǎn)換。對常量字符串使用cast不會(huì)起到任何作用，所以下面的代碼：

void SomeFunc ( LPCWSTR widestr );
main()
{
  SomeFunc ( (LPCWSTR) "C:\\foo.txt" );  // WRONG!
}      

C-style strings and typedefs

　　正如我在第一部分中提到的，windows APIs 是用TCHARs來定義的，在編譯時(shí)，它可以根據(jù)你是否定義_MBCS或者_(dá)UNICODE被編譯成MBCS或者Unicode字符。你可以參看第一部分中對TCHAR的完整描述，這里為了方便，我列出了字符的typedefs

　　一個(gè)增加的字符類型是OLETYPE。它表示自動(dòng)化接口（如word提供的可以使你操作文檔的接口）中使用的字符類型。這種類型一般被定義成wchar_t，然而如果你定義了OLE2ANSI預(yù)處理標(biāo)記，OLECHAR將會(huì)被定義成char類型。我知道現(xiàn)在已經(jīng)沒有理由定義OLE2ANSI（從MFC3以后，微軟已經(jīng)不使用它了），所以從現(xiàn)在起我將把OLECHAR當(dāng)作Unicode字符。
這里給出你將會(huì)看到的一些OLECHAR相關(guān)的typedefs：

　　還有兩個(gè)用于包圍字符串和字符常量的宏定義，它們可以使同樣的代碼被用于MBCS和Unicode builds ：

　　在文檔或例程中，你還會(huì)看到好多_T的變體。有四個(gè)等價(jià)的宏定義，它們是TEXT, _TEXT, __TEXT和__T，它們都起同樣的做用。

COM 中的字符串 —— BSTR 和 VARIANT

　　很多自動(dòng)化和COM接口使用BSTR來定義字符串。BSTRs中有幾個(gè)"陷阱"，所以這里我用單獨(dú)的部分來說明它。
　　BSTR 是 Pascal-style 字符串（字符串長度被明確指出）和C-style字符串（字符串的長度要通過尋找結(jié)束符來計(jì)算）的混合產(chǎn)物。一個(gè)BSTR是一個(gè)Unicode字符串，它的長度是預(yù)先考慮的，并且它還有一個(gè)0字符作為結(jié)束標(biāo)記。下面是一個(gè)BSTR的示例：

　

　　注意字符串的長度是如何被加到字符串?dāng)?shù)據(jù)中的。長度是DWORD類型的，保存了字符串中包含的字節(jié)數(shù)，但不包括結(jié)束標(biāo)記。在這個(gè)例子中，"Bob"包含3個(gè)Unicode字符（不包括結(jié)束符），總共6個(gè)字節(jié)。字符串的長度被預(yù)先存儲(chǔ)好，以便當(dāng)一個(gè)BSTR在進(jìn)程或者計(jì)算機(jī)之間被傳遞時(shí)，COM庫知道多少數(shù)據(jù)需要傳送。（另一方面，一個(gè)BSTR能夠存儲(chǔ)任意數(shù)據(jù)塊，而不僅僅是字符，它還可以包含嵌入在數(shù)據(jù)中的0字符。然而，由于這篇文章的目的，我將不考慮那些情況）。
　　在 C++ 中，一個(gè) BSTR 實(shí)際上就是一個(gè)指向字符串中第一個(gè)字符的指針。它的定義如下：

BSTR bstr = NULL;
  bstr = SysAllocString ( L"Hi Bob!" ); 
  if ( NULL == bstr )
    // out of memory error 
  // Use bstr here...
 SysFreeString ( bstr );      

// Constructing
_bstr_t bs1 = "char string";       // construct from a LPCSTR
_bstr_t bs2 = L"wide char string"; // construct from a LPCWSTR
_bstr_t bs3 = bs1;                 // copy from another _bstr_t
_variant_t v = "Bob";
_bstr_t bs4 = v;                   // construct from a _variant_t that has a string
 
// Extracting data
LPCSTR psz1 = bs1;              // automatically converts to MBCS string
LPCSTR psz2 = (LPCSTR) bs1;     // cast OK, same as previous line
LPCWSTR pwsz1 = bs1;            // returns the internal Unicode string
LPCWSTR pwsz2 = (LPCWSTR) bs1;  // cast OK, same as previous line
BSTR    bstr = bs1.copy();      // copies bs1, returns it as a BSTR
 
  // ...
SysFreeString ( bstr );      

// Constructing
_variant_t v1 = "char string";       // construct from a LPCSTR
_variant_t v2 = L"wide char string"; // construct from a LPCWSTR
_bstr_t bs1 = "Bob";
_variant_t v3 = bs1;                 // copy from a _bstr_t object
 
// Extracting data
_bstr_t bs2 = v1;           // extract BSTR from the VARIANT
_bstr_t bs3 = (_bstr_t) v1; // cast OK, same as previous line      

// Specializations
typedef basic_string tstring; // string of TCHARs
 
// Constructing
string str = "char string";         // construct from a LPCSTR
wstring wstr = L"wide char string"; // construct from a LPCWSTR
tstring tstr = _T("TCHAR string");  // construct from a LPCTSTR
 
// Extracting data
LPCSTR psz = str.c_str();    // read-only pointer to str‘‘s buffer
LPCWSTR pwsz = wstr.c_str(); // read-only pointer to wstr‘‘s buffer
LPCTSTR ptsz = tstr.c_str(); // read-only pointer to tstr‘‘s buffer

// Example, construct _bstr_t from basic_string
_bstr_t bs1 = str.c_str();  // construct a _bstr_t from a LPCSTR
_bstr_t bs2 = wstr.c_str(); // construct a _bstr_t from a LPCWSTR      

// Sample interface:
struct IStuff : public IUnknown
{
  // Boilerplate COM stuff omitted...
  STDMETHOD(SetText)(BSTR bsText);
  STDMETHOD(GetText)(BSTR* pbsText);
};      

CComBSTR bs1;
CComBSTR bs2 = "new text";
 
  pStuff->GetText ( &bs1 );       // ok, takes address of internal BSTR
  pStuff->SetText ( bs2 );        // ok, calls BSTR converter
  pStuff->SetText ( (BSTR) bs2 ); // cast ok, same as previous line      

// Constructing
CComBSTR bs1 = "char string";       // construct from a LPCSTR
CComBSTR bs2 = L"wide char string"; // construct from a LPCWSTR
CComBSTR bs3 = bs1;                 // copy from another CComBSTR
CComBSTR bs4;

  bs4.LoadString ( IDS_SOME_STR );  // load string from string table
// Extracting data
BSTR bstr1 = bs1;        // returns internal BSTR, but don‘‘t modify it!
BSTR bstr2 = (BSTR) bs1; // cast ok, same as previous line
BSTR bstr3 = bs1.Copy(); // copies bs1, returns it as a BSTR
BSTR bstr4;
  bstr4 = bs1.Detach();  // bs1 no longer manages its BSTR
  // ...
  SysFreeString ( bstr3 );
  SysFreeString ( bstr4 );      

std::list< CAdapt<CComBSTR> > bstr_list;

　　CAdapt提供容器所需要的操作符，但這些操作符對你的代碼是透明的。你可以把一個(gè)bstr_list當(dāng)作一個(gè)CComBSTR的list來使用。

CComVariant
　　CComVariant是VARIANT的封裝類。然而，不像_variant_t，在CComVariant中VARIANT沒有被隱藏。事實(shí)上你需要直接訪問VARIANT的成員。CComVariant提供了很多構(gòu)造函數(shù)來對VARIANT能夠包含的多種類型進(jìn)行處理。這里，我將只介紹和字符串相關(guān)的操作。

// Constructing
CComVariant v1 = "char string";       // construct from a LPCSTR
CComVariant v2 = L"wide char string"; // construct from a LPCWSTR
CComBSTR bs1 = "BSTR bob";
CComVariant v3 = (BSTR) bs1;          // copy from a BSTR
 
// Extracting data
CComBSTR bs2 = v1.bstrVal;            // extract BSTR from the VARIANT      

CComVariant v4 = ... // Init v4 from somewhere
CComBSTR bs3;
 
  if ( SUCCEEDED( v4.ChangeType ( VT_BSTR ) ))
    bs3 = v4.bstrVal;      

A: MBCS string, char* (A for ANSI)
W: Unicode string, wchar_t* (W for wide)
T: TCHAR string, TCHAR*
OLE: OLECHAR string, OLECHAR* (in practice, equivalent to W)
BSTR: BSTR (used as the destination type only)

　　所以，W2A()宏把一個(gè)Unicode字符串轉(zhuǎn)換成一個(gè)MBCS字符串。T2CW()宏把一個(gè)TCHAR字符串轉(zhuǎn)轉(zhuǎn)成一個(gè)Unicode字符串常量。
　　為了使用這些宏，需要先包含atlconv.h頭文件。你甚至可以在非ATL工程中包含這個(gè)頭文件來使用其中定義的宏，因?yàn)檫@個(gè)頭文件獨(dú)立于ATL中的其他部分，不需要一個(gè)_Module全局變量。當(dāng)你在一個(gè)函數(shù)中使用轉(zhuǎn)換宏時(shí)，需要把USES_CONVERSION宏放在函數(shù)的開頭。它定義了轉(zhuǎn)換宏所需的一些局部變量。
　　當(dāng)轉(zhuǎn)換的目的類型是除了BSTR以外的其他類型時(shí)，被轉(zhuǎn)換的字符串是存在棧中的。所以，如果你想讓字符串的生命周期比當(dāng)前的函數(shù)長，你需要把這個(gè)字符串拷貝到其他的字符串類中。當(dāng)目的類型是BSTR時(shí)，內(nèi)存不會(huì)自動(dòng)被釋放，你必須把返回值賦給一個(gè)BSTR變量或者一個(gè)BSTR封裝類以避免內(nèi)存泄漏。
　　下面是一些各種轉(zhuǎn)換宏的使用例子：

// Functions taking various strings:
void Foo ( LPCWSTR wstr );
void Bar ( BSTR bstr );
// Functions returning strings:
void Baz ( BSTR* pbstr );
#include <atlconv.h>
main()
{
using std::string;
USES_CONVERSION;    // declare locals used by the ATL macros
// Example 1: Send an MBCS string to Foo()
LPCSTR psz1 = "Bob";
string str1 = "Bob";
 
  Foo ( A2CW(psz1) );
  Foo ( A2CW(str1.c_str()) );
 
// Example 2: Send a MBCS and Unicode string to Bar()
LPCSTR psz2 = "Bob";
LPCWSTR wsz = L"Bob";
BSTR bs1;
CComBSTR bs2;
 
  bs1 = A2BSTR(psz2);         // create a BSTR
  bs2.Attach ( W2BSTR(wsz) ); // ditto, assign to a CComBSTR 
  Bar ( bs1 );
  Bar ( bs2 );
 
  SysFreeString ( bs1 );      // free bs1 memory
  // No need to free bs2 since CComBSTR will do it for us.
 
// Example 3: Convert the BSTR returned by Baz()
BSTR bs3 = NULL;
string str2;
  Baz ( &bs3 );          // Baz() fills in bs3
  str2 = W2CA(bs3);      // convert to an MBCS string
  SysFreeString ( bs3 ); // free bs3 memory
}      

// Constructing
CString s1 = "char string";  // construct from a LPCSTR
CString s2 = L"wide char string";  // construct from a LPCWSTR
CString s3 ( ‘‘ ‘‘, 100 );  // pre-allocate a 100-byte buffer, fill with spaces
CString s4 = "New window text";
 
  // You can pass a CString in place of an LPCTSTR:
  SetWindowText ( hwndSomeWindow, s4 );
 
  // Or, equivalently, explicitly cast the CString:
  SetWindowText ( hwndSomeWindow, (LPCTSTR) s4 );        

// Constructing/loading from string table
CString s5 ( (LPCTSTR) IDS_SOME_STR );  // load from string table
CString s6, s7; 
  // Load from string table.
  s6.LoadString ( IDS_SOME_STR );
 
  // Load printf-style format string from the string table:
  s7.Format ( IDS_SOME_FORMAT, "bob", nSomeStuff, ... );  

CString str = _T("new text");
LVITEM item = {0};
  item.mask = LVIF_TEXT;
  item.iItem = 1;
  item.pszText = (LPTSTR)(LPCTSTR) str; // WRONG!
  item.pszText = str.GetBuffer(0);      // correct
 
  ListView_SetItem ( &item );
str.ReleaseBuffer();  // return control of the buffer to str      

// Converting to BSTR
CString s5 = "Bob!";
BSTR bs1 = NULL, bs2 = NULL;
  bs1 = s5.AllocSysString();
  s5.SetSysString ( &bs2 );
  SysFreeString ( bs1 );
  SysFreeString ( bs2 );      

// Constructing
CString s1 = _T("tchar string");
COleVariant v1 = _T("Bob"); // construct from an LPCTSTR
COleVariant v2 = s1; // copy from a CString      

// Extracting data
COleVariant v3 = ...; // fill in v3 from somewhere
BSTR bs = NULL;
  try
    {
    v3.ChangeType ( VT_BSTR );
    bs = v3.bstrVal;
    }
  catch ( COleException* e )
    {
    // error, couldn‘‘t convert
    }
  SysFreeString ( bs );      

// Constructing
String* ms = S"This is a nice managed string";      

String* ms1 = S"this is nice";
String* ms2 = S"this is nice";
String* ms3 = L"this is nice";
  Console::WriteLine ( ms1 == ms2 ); // prints true
  Console::WriteLine ( ms1 == ms3);  // prints false      

  Console::WriteLine ( ms1->CompareTo(ms2) );
  Console::WriteLine ( ms1->CompareTo(ms3) );      

CString s1 ( "hello world" );
String* s2 ( s1 );  // copy from a CString      

String* s1 = S"Three cats";
CString s2 ( s1 );      

  CStringT ( System::String* pString );      

String* s1 = S"Three cats";
  Console::WriteLine ( s1 );
const __wchar_t __pin* pstr = PtrToStringChars(s1);
  for ( int i = 0; i < wcslen(pstr); i++ )
    (*const_cast<__wchar_t*>(pstr+i))++;
  Console::WriteLine ( s1 );      

_bstr_t bs = L"Bob!";
ATLTRACE("The string is: %s in line %d\n", (LPCSTR) bs, nLine);

　　如果你忘了使用轉(zhuǎn)換符而把整個(gè)_bstr_t對象傳給了函數(shù)，將會(huì)顯示一些毫無意義的輸出，因?yàn)開bstr_t保存的內(nèi)部數(shù)據(jù)會(huì)全部被輸出。

所有類的總結(jié)

　　兩個(gè)字符串類之間進(jìn)行轉(zhuǎn)換的常用方式是：先把源字符串轉(zhuǎn)換成一個(gè)C語言風(fēng)格的字符串指針，然后把這個(gè)指針傳遞給目的類型的構(gòu)造函數(shù)。下面這張表顯示了怎樣把一個(gè)字符串轉(zhuǎn)換成一個(gè)C語言風(fēng)格的字符串指針以及哪些類具有接收C語言風(fēng)格的字符串指針的構(gòu)造函數(shù)。