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

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


原著：Michael Dunn

作者：Chengjie Sun

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


 引言

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

Rule #1 of string classes

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

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

C-style strings and typedefs

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

　　一個增加的字符類型是OLETYPE。它表示自動化接口（如word提供的可以使你操作文檔的接口）中使用的字符類型。這種類型一般被定義成wchar_t，然而如果你定義了OLE2ANSI預處理標記，OLECHAR將會被定義成char類型。我知道現在已經沒有理由定義OLE2ANSI（從MFC3以後，微軟已經不使用它了），所以從現在起我將把OLECHAR當作Unicode字符。
這裏給出你將會看到的一些OLECHAR相關的typedefs：

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

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

 COM 中的字符串 —— BSTR 和 VARIANT

　　很多自動化和COM接口使用BSTR來定義字符串。BSTRs中有幾個"陷阱"，所以這裏我用單獨的部分來說明它。
　　BSTR 是 Pascal-style 字符串（字符串長度被明確指出）和C-style字符串（字符串的長度要通過尋找結束符來計算）的混合產物。一個BSTR是一個Unicode字符串，它的長度是預先考慮的，並且它還有一個0字符作為結束標記。下麵是一個BSTR的示例：

　

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

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提供容器所需要的操作符，但這些操作符對你的代碼是透明的。你可以把一個bstr_list當作一個CComBSTR的list來使用。

CComVariant
　　CComVariant是VARIANT的封裝類。然而，不像_variant_t，在CComVariant中VARIANT沒有被隱藏。事實上你需要直接訪問VARIANT的成員。CComVariant提供了很多構造函數來對VARIANT能夠包含的多種類型進行處理。這裏，我將隻介紹和字符串相關的操作。

// 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()宏把一個Unicode字符串轉換成一個MBCS字符串。T2CW()宏把一個TCHAR字符串轉轉成一個Unicode字符串常量。
　　為了使用這些宏，需要先包含atlconv.h頭文件。你甚至可以在非ATL工程中包含這個頭文件來使用其中定義的宏，因為這個頭文件獨立於ATL中的其他部分，不需要一個_Module全局變量。當你在一個函數中使用轉換宏時，需要把USES_CONVERSION宏放在函數的開頭。它定義了轉換宏所需的一些局部變量。
　　當轉換的目的類型是除了BSTR以外的其他類型時，被轉換的字符串是存在棧中的。所以，如果你想讓字符串的生命周期比當前的函數長，你需要把這個字符串拷貝到其他的字符串類中。當目的類型是BSTR時，內存不會自動被釋放，你必須把返回值賦給一個BSTR變量或者一個BSTR封裝類以避免內存泄漏。
　　下麵是一些各種轉換宏的使用例子：

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

　　如果你忘了使用轉換符而把整個_bstr_t對象傳給了函數，將會顯示一些毫無意義的輸出，因為_bstr_t保存的內部數據會全部被輸出。

 所有類的總結

　　兩個字符串類之間進行轉換的常用方式是：先把源字符串轉換成一個C語言風格的字符串指針，然後把這個指針傳遞給目的類型的構造函數。下麵這張表顯示了怎樣把一個字符串轉換成一個C語言風格的字符串指針以及哪些類具有接收C語言風格的字符串指針的構造函數。