📄 subject_21948.htm
字号:
<blockquote><p>
<font color=red>答案被接受</font><br>回复者：徐景周 回复日期：2002-11-21 14:20:03
<br>内容：CString to BSTR <BR>When programming with ActiveX, you will sometimes need a value represented as a type BSTR. A BSTR is a counted string, a wide-character (Unicode) string on Intel platforms and can contain embedded NUL characters. <BR>You can convert at CString to a BSTR by calling the CString method AllocSysString: <BR>CString s;<BR>s = ... ; // whatever<BR>BSTR b = s.AllocSysString()<BR> The pointer b points to a newly-allocated BSTR object which is a copy of the CString, including the terminal NUL character. This may now be passed to whatever interface you are calling that requires a BSTR. Normally, a BSTR is disposed of by the component receiving it. If you should need to dispose of a BSTR, you must use the call <BR>::SysFreeString(b);<BR>to free the string. <BR>The story is that the decision of how to represent strings sent to ActiveX controls resulted in some serious turf wars within Microsoft. The Visual Basic people won, and the string type BSTR (acronym for "Basic String") was the result. <BR>BSTR to CString <BR> Since a BSTR is a counted Unicode string, you can use standard conversions to make an 8-bit CString. Actually, this is built-in; there are special constructors for converting ANSI strings to Unicode and vice-versa. You can also get BSTRs as results in a VARIANT type, which is a type returned by various COM and Automation calls. <BR>For example, if you do, in an ANSI application, <BR>BSTR b;<BR>b = ...; // whatever<BR>CString s(b == NULL ? L"" : s)<BR>works just fine for a single-string BSTR, because there is a special constructor that takes an LPCWSTR (which is what a BSTR is) and converts it to an ANSI string. The special test is required because a BSTR could be NULL, and the constructors Don't Play Well with NULL inputs (thanks to Brian Ross for pointing this out!). This also only works for a BSTR that contains only a single string terminated with a NUL; you have to do more work to convert strings that contain multiple NUL characters. Note that embedded NUL characters generally don't work well in CStrings and generally should be avoided. <BR>Remember, according to the rules of C/C++, if you have an LPWSTR it will match a parameter type of LPCWSTR (it doesn't work the other way!). <BR>In UNICODE mode, this is just the constructor <BR><code>CString::CString(LPCTSTR);<BR>As indicated above, in ANSI mode there is a special constructor for <BR><code>CString::CString(LPCWSTR); <BR>this calls an internal function to convert the Unicode string to an ANSI string. (In Unicode mode there is a special constructor that takes an LPCSTR, a pointer to an 8-bit ANSI string, and widens it to a Unicode string!). Again, note the limitation imposed by the need to test for a BSTR value which is NULL. <BR>There is an additional problem as pointed out above: BSTRs can contain embedded NUL characters; CString constructors can only handle single NUL characters in a string. This means that CStrings will compute the wrong length for a string which contains embedded NUL bytes. You need to handle this yourself. If you look at the constructors in strcore.cpp, you will see that they all do an lstrlen or equivalent to compute the length. <BR>Note that the conversion from Unicode to ANSI uses the ::WideCharToMultiByte conversion with specific arguments that you may not like. If you want a different conversion than the default, you have to write your own. <BR>If you are compiling as UNICODE, then it is a simple assignment: <BR><code>CString convert(BSTR b)<BR> {<BR> if(b == NULL)<BR> return CString(_T(""));<BR> CString s(b); // in UNICODE mode<BR> return s;<BR> }<BR>If you are in ANSI mode, you need to convert the string in a more complex fashion. This will accomplish it. Note that this code uses the same argument values to ::WideCharToMultiByte that the implicit constructor for CString uses, so you would use this technique only if you wanted to change these parameters to do the conversion in some other fashion, for example, specifying a different default character, a different set of flags, etc. <BR><code>CString convert(BSTR b)<BR> {<BR> CString s;<BR> if(b == NULL)<BR> return s; // empty for NULL BSTR<BR>#ifdef UNICODE<BR> s = b;<BR>#else<BR> LPSTR p = s.GetBuffer(SysStringLen(b) + 1); <BR> ::WideCharToMultiByte(CP_ACP, // ANSI Code Page<BR> 0, // no flags<BR> b, // source widechar string<BR> -1, // assume NUL-terminated<BR> p, // target buffer<BR> SysStringLen(b)+1, // target buffer length<BR> NULL, // use system default char<BR> NULL); // don't care if default used<BR> s.ReleaseBuffer();<BR>#endif<BR> return s;<BR> }<BR>Note that I do not worry about what happens if the BSTR contains Unicode characters that do not map to the 8-bit character set, because I specify NULL as the last two parameters. This is the sort of thing you might want to change. <BR>VARIANT to CString <BR>Actually, I've never done this; I don't work in COM/OLE/ActiveX where this is an issue. But I saw a posting by Robert Quirk on the microsoft.public.vc.mfc newsgroup on how to do this, and it seemed silly not to include it in this essay, so here it is, with a bit more explanation and elaboration. Any errors relative to what he wrote are my fault. <BR>A VARIANT is a generic parameter/return type in COM programming. You can write methods that return a type VARIANT, and which type the function returns may (and often does) depend on the input parameters to your method (for example, in Automation, depending on which method you call, IDispatch::Invoke may return (via one of its parameters) a VARIANT which holds a BYTE, a WORD, an float, a double, a date, a BSTR, and about three dozen other types (see the specifications of the VARIANT structure in the MSDN). In the example below, it is assumed that the type is known to be a variant of type BSTR, which means that the value is found in the string referenced by bstrVal. This takes advantage of the fact that there is a constructor which, in an ANSI application, will convert a value referenced by an LPCWCHAR to a CString (see BSTR-to-CString). In Unicode mode, this turns out to be the normal CString constructor. See the caveats about the default ::WideCharToMultibyte conversion and whether or not you find these acceptable (mostly, you will). <BR>VARIANT vaData;<BR><BR>vaData = m_com.YourMethodHere();<BR>ASSERT(vaData.vt == VT_BSTR);<BR><BR>CString strData(vaData.bstrVal);<BR>Note that you could also make a more generic conversion routine that looked at the vt field. In this case, you might consider something like: <BR>CString VariantToString(VARIANT * va)<BR> {<BR> CString s;<BR> switch(va->vt)<BR> { /* vt */<BR> case VT_BSTR:<BR> return CString(vaData->bstrVal);<BR> case VT_BSTR | VT_BYREF:<BR> return CString(*vaData->pbstrVal);<BR> case VT_I4:<BR> s.Format(_T("%d"), va->lVal);<BR> return s;<BR> case VT_I4 | VT_BYREF:<BR> s.Format(_T("%d"), *va->plVal);<BR> case VT_R8:<BR> s.Format(_T("%f"), va->dblVal);<BR> return s;<BR> ... remaining cases left as an Exercise For The Reader<BR> default:<BR> ASSERT(FALSE); // unknown VARIANT type (this ASSERT is optional)<BR> return CString("");<BR> } /* vt */<BR> }<BR>Loading STRINGTABLE values <BR>If you want to create a program that is easily ported to other languages, you must not include native-language strings in your source code. (For these examples, I'll use English, since that is my native language (aber Ich kann ein bischen Deutsch sprechen). So it is very bad practice to write <BR>CString s = "There is an error";<BR>Instead, you should put all your language-specific strings (except, perhaps, debug strings, which are never in a product deliverable). This means that is fine to write <BR>s.Format(_T("%d - %s"), code, text);<BR>in your program; that literal string is not language-sensitive. However, you must be very careful to not use strings like <BR>// fmt is "Error in %s file %s"<BR>// readorwrite is "reading" or "writing"<BR>s.Format(fmt, readorwrite, filename); <BR>I speak of this from experience. In my first internationalized application I made this error, and in spite of the fact that I know German, and that German word order places the verb at the end of a sentence, I had done this. Our German distributor complained bitterly that he had to come up with truly weird error messages in German to get the format codes to do the right thing. It is much better (and what I do now) to have two strings, one for reading and one for writing, and load the appropriate one, making them string parameter-insensitive, that is, instead of loading the strings "reading" or "writing", load the whole format: <BR>// fmt is "Error in reading file %s"<BR>// "Error in writing file %s"<BR>s.Format(fmt, filename);<BR>Note that if you have more than one substitution, you should make sure that if the word order of the substitutions does not matter, for example, subject-object, subject-verb, or verb-object, in English. <BR>For now, I won't talk about FormatMessage, which actually is better than sprintf/Format, but is poorly integrated into the CString class. It solves this by naming the parameters by their position in the parameter list and allows you to rearrange them in the output string. <BR>So how do we accomplish all this? By storing the string values in the resource known as the STRINGTABLE in the resource segment. To do this, you must first create the string, using the Visual Studio resource editor. A string is given a string ID, typically starting IDS_. So you have a message, you create the string and call it IDS_READING_FILE and another called IDS_WRITING_FILE. They appear in your .rc file as <BR>STRINGTABLE<BR> IDS_READING_FILE "Reading file %s"<BR> IDS_WRITING_FILE "Writing file %s"<BR>END<BR>Note: these resources are always stored as Unicode strings, no matter what your program is compiled as. They are even Unicode strings on Win9x platforms, which otherwise have no real grasp of Unicode (but they do for resources!). Then you go to where you had stored the strings <BR>// previous code<BR> CString fmt;<BR> if(...)<BR> fmt = "Reading file %s";<BR> else<BR> fmt = "Writing file %s";<BR> ...<BR> // much later<BR> CString s;<BR> s.Format(fmt, filename);<BR>and instead do <BR>// revised code<BR> CString fmt;<BR> if(...)<BR> fmt.LoadString(IDS_READING_FILE);<BR> else<BR> fmt.LoadString(DS_WRITING_FILE);<BR> ...<BR> // much later<BR> CString s;<BR> s.Format(fmt, filename);<BR>Now your code can be moved to any language. The LoadString method takes a string ID and retrieves the STRINGTABLE value it represents, and assigns that value to the CString. <BR>There is a clever feature of the CString constructor that simplifies the use of STRINGTABLE entries. It is not explicitly documented in the CString::CString specification, but is obscurely shown in the example usage of the constructor! (Why this couldn't be part of the formal documentation and has to be shown in an example escapes me!). The feature is that if you cast a STRINGTABLE ID to an LPCTSTR it will implicitly do a LoadString. Thus the following two examples of creating a string value produce the same effect, and the ASSERT will not trigger in debug mode compilations: <BR>CString s;<BR>s.LoadString(IDS_WHATEVER);<BR>CString t( (LPCTSTR)IDS_WHATEVER);<BR>ASSERT(s == t);<BR>Now, you may say, how can this possibly work? How can it tell a valid pointer from a STRINGTABLE ID? Simple: all string IDs are in the range 1..65535. This means that the high-order bits of the pointer will be 0. Sounds good, but what if I have valid data in a low address? Well, the answer is, you can't. The lower 64K of your address space will never, ever, exist. Any attempt to access a value in the address range 0x00000000 through 0x0000FFFF (0..65535) will always and forever give an access fault. These addresses are never, ever valid addresses. Thus a value in that range (other than 0) must necessarily represent a STRINGTABLE ID. <BR>I tend to use the MAKEINTRESOURCE macro to do the casting. I think it makes the code clearer regarding what is going on. It is a standard macro which doesn't have much applicability otherwise in MFC. You may have noted that many methods take either a UINT or an LPCTSTR as parameters, using C++ overloading. This gets us around the ugliness of pure C where the "overloaded" methods (which aren't really overloaded in C) required explicit casts. This is also useful in assigning resource names to various other structures. <BR>CString s;<BR>s.LoadString(IDS_WHATEVER);<BR>CString t( MAKEINTRESOURCE(IDS_WHATEVER));<BR>ASSERT(s == t);<BR>Just to give you an idea: I practice what I preach here. You will rarely if ever find a literal string in my program, other than the occasional debug output messages, and, of course, any language-independent string. <BR>
<br>
<a href="javascript:history.go(-1)">返回上页</a><br><a href=http://www.copathway.com/cndevforum/>访问论坛</a></p></blockquote>
<hr size=1>
<blockquote><p>
回复者：超超 回复日期：2002-11-21 14:58:56
<br>内容：不管怎样还是要说声谢谢！但是是否能够提供中文的资料！
<br>
<a href="javascript:history.go(-1)">返回上页</a><br><a href=http://www.copathway.com/cndevforum/>访问论坛</a></p></blockquote>
<hr size=1>
<blockquote><p>
回复者：徐景周 回复日期：2002-11-21 15:10:40
<br>内容：已发到你信箱中
<br>
<a href="javascript:history.go(-1)">返回上页</a><br><a href=http://www.copathway.com/cndevforum/>访问论坛</a></p></blockquote>
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -