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

ATL转换宏

　　ATL：转换宏是各种字符编码之间进行转换的一种很方便的方式，在函数调用时，它们显得非常有用。ATL转换宏的名称是根据下面的模式来命名的[源类型]2[新类型]或者[源类型]2C[新类型]。据有第二种形式的名字的宏的转换结果是常量指针（对应名字中的"C"）。各种类型的简称如下：

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 
            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
            }      

　　正如你所看见的，当你有一个和函数所需的参数类型不同的字符串时，使用这些转换宏是非常方便的。

MFC类

CString
　　因为一个MFC CString类的对象包含TCHAR类型的字符，所以确切的字符类型取决于你所定义的预处理符号。大体来说，CString 很像STL string，这意味着你必须把它当成不透明的对象，只能使用CString提供的方法来修改CString对象。CString有一个string所不具备的优点：CString具有接收MBCS和Unicode两种字符串的构造函数，它还有一个LPCTSTR转换符，所以你可以把CString对象直接传给一个接收LPCTSTR的函数而不需要调用c_str()函数。

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

　　你可以从你的字符串表中装载一个字符串，CString的一个构造函数和LoadString()函数可以完成它。Format()方法能够从字符串表中随意的读取一个具有一定格式的字符串。　　　　　

// 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变量，你可以使用的唯一合法转换符是LPCTSTR。转换成LPTSTR（非常量指针）是错误的。养成把一个CString变量转换成LPTSTR的习惯将会给你带来伤害，因为当你的程序后来崩溃时，你可能不知道为什么，因为你到处都使用同样的代码而那时它们都恰巧正常工作。正确的得到一个指向缓冲区的非常量指针的方法是调用GetBuffer()方法。下面是正确的用法的一个例子，这段代码是给一个列表控件中的项设定文字：

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      

　　pszText成员是一个LPTSTR变量，一个非常量指针，因此你需要对str调用GetBuffer()。GetBuffer()的参数是你需要CString为缓冲区分配的最小长度。如果因为某些原因，你需要一个可修改的缓冲区来存放1K TCHARs，你需要调用GetBuffer(1024)。把0作为参数时，GetBuffer()返回的是指向字符串当前内容的指针。
　　上面划线的语句可以被编译，在这种情况下，甚至可以正常起作用。但这并不意味着这行代码是正确的。通过使用非常量转换，你已经破坏了面向对象的封装，并对CString的内部实现作了某些假定。如果你有这样的转换习惯，你终将会陷入代码崩溃的境地。你会想代码为什么不能正常工作了，因为你到处都使用同样的代码而那些代码看起来是正确的。
　　你知道人们总是抱怨现在的软件的bug是多么的多吗？软件中的bug是因为程序员写了不正确的代码。难道你真的想写一些你知道是错误的代码来为所有的软件都满是bug这种认识做贡献吗？花些时间来学习使用CString的正确方法让你的代码在任何时间都正常工作把。
　　CString 有两个函数来从一个 CString 创建一个 BSTR。它们是 AllocSysString() 和SetSysString()。

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

COleVariant
　　COleVariant和CComVariant.很相似。COleVariant继承自VARIANT，所以它可以传给接收VARIANT的函数。然而，不像CComVariant，COleVariant只有一个LPCTSTR构造函数。没有对LPCSTR 和LPCWSTR的构造函数。在大多数情况下这不是一个问题，因为不管怎样你的字符串很可能是LPCTSTRs，但这是一个需要意识到的问题。COleVariant还有一个接收CString参数的构造函数。

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

　　像CComVariant一样，你必须直接访问VARIANT的成员。如果需要把VARIANT转换成一个字符串，你应该使用ChangeType()方法。然而，COleVariant::ChangeType()如果失败会抛出异常，而不是返回一个表示失败的HRESULT代码。

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

WTL 类

CString
　　WTL的CString的行为和MFC的 CString完全一样，所以你可以参考上面关于MFC的 CString的介绍。

CLR 和 VC 7 类

　　System::String是用来处理字符串的.NET类。在内部，一个String对象包含一个不可改变的字符串序列。任何对String对象的操作实际上都是返回了一个新的String对象，因为原始的对象是不可改变的。String的一个特性是如果你有不止一个String对象包含相同的字符序列，它们实际上是指向相同的对象的。相对于C++的使用扩展是增加了一个新的字符串常量前缀S，S用来代表一个受控的字符串常量（a managed string literal）。

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

　　你可以传递一个非受控的字符串来创建一个String对象，但是样会比使用受控字符串来创建String对象造成效率的微小损失。这是因为所有以S作为前缀的相同的字符串实例都代表同样的对象，但这对非受控对象是不适用的。下面的代码清楚地阐明了这一点：

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      

正确的比较可能没有使用S前缀的字符串的方法是使用String::CompareTo()

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

　　上面的两行代码都会打印0，0表示两个字符串相等。 String和MFC 7 CString之间的转换是很容易的。CString有一个向LPCTSTR的转换操作，而String有两个接收char* 和 wchar_t*的构造函数，因此你可以把一个CString变量直接传给一个String的构造函数。

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

反方向的转换也很类似

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

　　这也许会使你感到一点迷惑，但是它确实是起作用的。因为从VS.NET 开始，CString 有了一个接收String 对象的构造函数。

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

　　PtrToStringChars()返回一个指向底层字符串的const __wchar_t* ，我们需要固定它，否则垃圾收集器或许会在我们正在管理它的内容的时候移动了它。

在 printf-style 格式函数中使用字符串类

　　当你在printf()或者类似的函数中使用字符串封装类时你必须十分小心。这些函数包括sprintf()和它的变体，还有TRACE和ATLTRACE宏。因为这些函数没有对添加的参数的类型检查，你必须小心，只能传给它们C语言风格的字符串指针，而不是一个完整的字符串类。
　　例如，要把一个_bstr_t 字符串传给ATLTRACE()，你必须使用显式转换(LPCSTR) 或者(LPCWSTR)：

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

　　如果你忘了使用转换符而把整个_bstr_t对象传给了函数，将会显示一些毫无意义的输出，因为_bstr_t保存的内部数据会全部被输出。

所有类的总结

　　两个字符串类之间进行转换的常用方式是：先把源字符串转换成一个C语言风格的字符串指针，然后把这个指针传递给目的类型的构造函数。下面这张表显示了怎样把一个字符串转换成一个C语言风格的字符串指针以及哪些类具有接收C语言风格的字符串指针的构造函数。

Class	string type	convert to char*?	convert to const char*?	convert to wchar_t*?	convert to const wchar_t*?	convert to BSTR?	construct from char*?	construct from wchar_t*?
_bstr_t	BSTR	yes cast1	yes cast	yes cast1	yes cast	yes2	yes	yes
_variant_t	BSTR	no	no	no	cast to _bstr_t3	cast to _bstr_t3	yes	yes
string	MBCS	no	yes c_str() method	no	no	no	yes	no
wstring	Unicode	no	no	no	yes c_str() method	no	no	yes
CComBSTR	BSTR	no	no	no	yes cast to BSTR	yes cast	yes	yes
CComVariant	BSTR	no	no	no	yes4	yes4	yes	yes
CString	TCHAR	no6	in MBCS builds, cast	no6	in Unicode builds, cast	no5	yes	yes
COleVariant	BSTR	no	no	no	yes4	yes4	in MBCS builds	in Unicode builds
1、即使 _bstr_t 提供了向非常量指针的转换操作符，修改底层的缓冲区也会已引起GPF如果你溢出了缓冲区或者造成内存泄漏。 2、_bstr_t 在内部用一个 wchar_t* 来保存 BSTR，所以你可以使用 const wchar_t* 来访问BSTR。这是一个实现细节，你可以小心的使用它，将来这个细节也许会改变。 3、如果数据不能转换成BSTR会抛出一个异常。 4、使用 ChangeType()，然后访问 VARIANT 的 bstrVal 成员。在MFC中，如果数据转换不成功将会抛出异常。 5、这里没有转换 BSTR 函数，然而 AllocSysString() 返回一个新的BSTR。 6、使用 GetBuffer() 方法，你可以暂时地得到一个非常量的TCHAR指针。