数学建模社区-数学中国

标题: [转帖]C++字符串完全指引之一 —— Win32 字符编码 [打印本页]
作者: rashige    时间: 2004-4-29 10:04
标题: [转帖]C++字符串完全指引之一 —— Win32 字符编码
<>原著：Michael Dunn* H5 q- M& q) Y/ C+ o1 f4 g
6 p/ R' @6 n% d6 X
翻译：<a href="mailtcjsun@insun.hit.edu.cn" target="_blank" >Chengjie Sun</A></P>) n. {. d8 u9 g7 N
<>原文出处：<FONT size=2><a href="http://www.codeproject.com/string/cppstringguide1.asp" target="_blank" >CodeProject：The Complete Guide to C++ Strings, Part I</A></FONT></P>
" k0 y' g1 a* ?
; @" @" n) t* f3 p4 P<>+ I" R7 ^" S" p+ v
<TABLE cellSpacing=0 cellPadding=0 width="100%" border=0>
  p0 V4 O& t/ \) X& m9 z. l% Y( v* c. w' n
<TR>6 B8 @# g. j4 d
<TD>
+ t* L( Q; N7 J' R: T<><B>引言</B>
3 j" B& W: s5 D# k; i9 f9 m  @: N* z7 l
　　毫无疑问，我们都看到过像 TCHAR, std::string, BSTR 等各种各样的字符串类型，还有那些以 _tcs 开头的奇怪的宏。你也许正在盯着显示器发愁。本指引将总结引进各种字符类型的目的，展示一些简单的用法，并告诉您在必要时，如何实现各种字符串类型之间的转换。  j( r6 b) F3 i' f
　　在第一部分，我们将介绍3种字符编码类型。了解各种编码模式的工作方式是很重要的事情。即使你已经知道一个字符串是一个字符数组，你也应该阅读本部分。一旦你了解了这些，你将对各种字符串类型之间的关系有一个清楚地了解。
4 b6 z( k. J1 {3 _2 Y! X  S; w　　在第二部分，我们将单独讲述string类，怎样使用它及实现他们相互之间的转换。# m$ O! y3 [, f) e9 J+ b, O

8 @3 r! q8 J; a<IMG src="http://www.vckbase.com/document/image/paragraph.gif"> <B>字符基础 -- ASCII, DBCS, Unicode</B>
" |6 W0 }5 ^/ o4 }5 k  Q
' q  f1 j, c% D9 [7 V　　所有的 string 类都是以C-style字符串为基础的。C-style 字符串是字符数组。所以我们先介绍字符类型。这里有3种编码模式对应3种字符类型。第一种编码类型是单子节字符集（single-byte character set or SBCS）。在这种编码模式下，所有的字符都只用一个字节表示。ASCII是SBCS。一个字节表示的0用来标志SBCS字符串的结束。; E+ F) G1 m" N* A, o; e! R, }
　　第二种编码模式是多字节字符集（multi-byte character set or MBCS）。一个MBCS编码包含一些一个字节长的字符，而另一些字符大于一个字节的长度。用在Windows里的MBCS包含两种字符类型，单字节字符（single-byte characters）和双字节字符（double-byte characters）。由于Windows里使用的多字节字符绝大部分是两个字节长，所以MBCS常被用DBCS代替。* H+ E1 z3 W9 u3 i
　　在DBCS编码模式中，一些特定的值被保留用来表明他们是双字节字符的一部分。例如，在Shift-JIS编码中（一个常用的日文编码模式），0x81-0x9f之间和 0xe0-oxfc之间的值表示"这是一个双字节字符，下一个子节是这个字符的一部分。"这样的值被称作"leading bytes",他们都大于0x7f。跟随在一个leading byte子节后面的字节被称作"trail byte"。在DBCS中，trail byte可以是任意非0值。像SBCS一样，DBCS字符串的结束标志也是一个单字节表示的0。
- c8 H$ v7 O7 u# x　　第三种编码模式是Unicode。Unicode是一种所有的字符都使用两个字节编码的编码模式。Unicode字符有时也被称作宽字符，因为它比单子节字符宽（使用了更多的存储空间）。注意，Unicode不能被看作MBCS。MBCS的独特之处在于它的字符使用不同长度的字节编码。Unicode字符串使用两个字节表示的0作为它的结束标志。5 E( E( A* p5 A8 S# q) b6 N/ y
　　单字节字符包含拉丁文字母表，accented characters及ASCII标准和DOS操作系统定义的图形字符。双字节字符被用来表示东亚及中东的语言。Unicode被用在COM及Windows NT操作系统内部。
+ V7 g$ p! i/ z' j  Z+ y1 k. v　　你一定已经很熟悉单字节字符。当你使用char时，你处理的是单字节字符。双字节字符也用char类型来进行操作（这是我们将会看到的关于双子节字符的很多奇怪的地方之一）。Unicode字符用wchar_t来表示。Unicode字符和字符串常量用前缀L来表示。例如：</P><RE>wchar_t wch = L''1''; // 2 bytes, 0x0031
7 l; c8 x5 |: V- Jwchar_t* wsz = L"Hello"; // 12 bytes, 6 wide characters</PRE>/ C% c" [' K6 L
<><IMG src="http://www.vckbase.com/document/image/paragraph.gif"> <B>字符在内存中是怎样存储的</B>8 q! n& L" R! C7 P& o
  u- h- {6 |, F) p
　　单字节字符串：每个字符占一个字节按顺序依次存储，最后以单字节表示的0结束。例如。"Bob"的存贮形式如下：</P>: c! F" k$ z* e% q* m
<TABLE>" I% N3 G1 R5 k! m5 h- M% v! U
( ]* Z* J" k, t5 o
<TR>
" @$ G1 \6 M: u: v8 x<TD align=middle width="25%">42</TD>3 ?" E, }6 `1 |9 [" Y; m7 D5 S
<TD align=middle width="25%"><FONT color=#990000>6F</FONT></TD>
' H9 i, U5 d4 p<TD align=middle width="25%">62</TD>9 V! n( w6 \& g. f* @4 n
<TD align=middle width="25%">00</TD></TR>
  C6 ~" q( m) N  K# @3 A- }<TR>
" J9 ]; d# _4 {" h7 M7 f" M. e<TD align=middle width="25%"><FONT color=#990000>B</FONT></TD>
8 ~5 X) u1 Q6 _$ u9 e2 L<TD align=middle width="25%"><FONT color=#990000>o</FONT></TD>1 p6 y4 v7 C$ f) T5 {0 c+ d
<TD align=middle width="25%"><FONT color=#990000>b</FONT></TD>& S  W" o; H  F) \( n
<TD align=middle width="25%"><FONT color=#990000>BOS</FONT></TD></TR></TABLE># B& a* g" o+ l& X5 f+ f3 \- Y
<>Unicode的存储形式，L"Bob"</P>  S; D9 H6 f! Z# j+ \
<TABLE>
) O! I1 Q) ?# k' i/ u  l
, `  g3 p3 b2 D8 j; f+ N<TR>
2 s0 S: I0 [- B) }<TD align=middle width="25%">42 00 </TD>: d% ]3 e2 G3 w7 {( ~
<TD align=middle width="25%"><FONT color=#990000>6F</FONT> 00</TD>7 \: e% z$ {+ H5 g1 ]' S
<TD align=middle width="25%">62 00</TD>/ ]: i. I% l; j4 v+ D
<TD align=middle width="25%">00 00</TD></TR>+ L/ X8 {# j# x7 ]7 e8 p7 I5 ^
<TR>
# l. M" j8 t. [& h1 n$ ]6 t<TD align=middle width="25%"><FONT color=#990000>B</FONT></TD>
  m5 w* V" O4 |' ]6 g- t<TD align=middle width="25%"><FONT color=#990000>o</FONT></TD>+ K  [. K9 L/ L
<TD align=middle width="25%"><FONT color=#990000>b</FONT></TD>
+ x5 t9 ^# F& ~6 H, h<TD align=middle width="25%"><FONT color=#990000>BOS</FONT></TD></TR></TABLE>
- O# ~8 }4 l& t) ^<>使用两个字节表示的0来做结束标志。9 y2 O0 T. p6 F/ I9 h# ?4 V9 L
+ l/ l* T7 Z2 F% w0 L: d
　　一眼看上去，DBCS 字符串很像 SBCS 字符串，但是我们一会儿将看到 DBCS 字符串的微妙之处，它使得使用字符串操作函数和永字符指针遍历一个字符串时会产生预料之外的结果。字符串" " ("nihongo")在内存中的存储形式如下（LB和TB分别用来表示 leading byte 和 trail byte）</P>
/ `3 H9 U' Z( {! T<TABLE>
* b9 [, w: F1 A& R9 v
. u+ y5 v9 C' x' o1 q<TR>2 A5 Z6 g; {: ~3 f: q
<TD align=middle width="25%" height=20>93 <FONT color=#990000>FA</FONT></TD>9 Q9 Z+ x) z) U9 k5 z* B$ @6 w3 K+ x
<TD align=middle width="25%" height=20>96 <FONT color=#990000>7B</FONT></TD>. `- ]1 F; w2 S
<TD align=middle width="25%" height=20><FONT color=#990000>8C EA</FONT></TD>- _% j" @+ P6 ], y& D! f
<TD align=middle width="25%" height=20>00</TD></TR>+ w# r- ]2 j5 @; G! {6 L% O5 d
<TR>7 g/ N, e% W( d5 O4 B, J3 ?
<TD align=middle width="25%" height=20><FONT color=#990000>LB TB</FONT></TD>% ~0 ~: k) a8 j: X9 C( `' V
<TD align=middle width="25%" height=20><FONT color=#990000>LB TB</FONT></TD>3 `6 u/ R6 y# i) ]
<TD align=middle width="25%" height=20><FONT color=#990000>LB TB</FONT></TD>3 ~: T0 ]% z7 e1 d- ^- ^# h
<TD align=middle width="25%" height=20><FONT color=#990000>EOS</FONT></TD></TR>
9 T# ]: F- k% K: u- Z<TR>
! X0 w4 m9 g6 {9 b2 ?<TD align=middle width="25%" height=20><IMG src="http://www.vckbase.com/document/journal/vckbase30/images/ri.gif" border=0></TD>7 f5 l* F3 x0 U
<TD align=middle width="25%" height=20><IMG src="http://www.vckbase.com/document/journal/vckbase30/images/ben.gif" border=0></TD>8 Y  f1 V7 k* j# ~# {' ]
<TD align=middle width="25%" height=20><IMG src="http://www.vckbase.com/document/journal/vckbase30/images/yu.gif" border=0></TD>- l0 k4 H$ |5 E" ]2 B9 E% h
<TD align=middle width="25%" height=20><FONT color=#990000>EOS</FONT></TD></TR></TABLE>) O+ \' ~4 \% r. C) A
<>值得注意的是，"ni"的值不能被解释成WORD型值0xfa93，而应该看作两个值93和fa以这种顺序被作为"ni"的编码。6 z) l5 D2 H4 g* ]. m# B
5 Q/ r0 k5 ?# ^9 d* B
<IMG src="http://www.vckbase.com/document/image/paragraph.gif"> <B>使用字符串处理函数</B>
! c% _; J+ s$ e! Z6 L* ^" ~& D% G" s3 h9 L! W
　　我们都已经见过C语言中的字符串函数，strcpy(), sprintf(), atoll()等。这些字符串只应该用来处理单字节字符字符串。标准库也提供了仅适用于Unicode类型字符串的函数，比如wcscpy(), swprintf(), wtol()等。' N. Y! z9 i1 w' q) I1 d: o" u" D6 ?
　　微软还在它的CRT(C runtime library)中增加了操作DBCS字符串的版本。Str***()函数都有对应名字的DBCS版本_mbs***()。如果你料到可能会遇到DBCS字符串（如果你的软件会被安装在使用DBCS编码的国家，如中国，日本等，你就可能会），你应该使用_mbs***()函数，因为他们也可以处理SBCS字符串。（一个DBCS字符串也可能含有单字节字符，这就是为什么_mbs***()函数也能处理SBCS字符串的原因）/ ?6 h/ S# s! H: ?, d1 q1 m# p4 F$ c
　　让我们来看一个典型的字符串来阐明为什么需要不同版本的字符串处理函数。我们还是使用前面的Unicode字符串 L"Bob"：</P>
3 e% [! g4 U( ~, _. [% ?& K* l<TABLE>
0 ?, _' J6 I  D5 Z4 p. S/ e) M. E; J: _
<TR>
, N7 f+ U/ r5 ?* C' V( W4 A! h<TD align=middle width="25%">42 00 </TD>4 u% J2 g) k% ?* c& ?7 a
<TD align=middle width="25%"><FONT color=#990000>6F</FONT> 00</TD>$ }( |6 Y) R0 Q1 y8 X6 _9 X7 [
<TD align=middle width="25%">62 00</TD>
, V: z- o% ~# ~1 g" H7 ~<TD align=middle width="25%">00 00</TD></TR>
* D& {0 q* d, k' @$ R- v. O0 w<TR>
0 ]  J" o( K: |<TD align=middle width="25%"><FONT color=#990000>B</FONT></TD>5 h, B0 I2 U- }1 J  w" c* t
<TD align=middle width="25%"><FONT color=#990000>o</FONT></TD>
- N4 x) x! i. O2 }. M7 C" x<TD align=middle width="25%"><FONT color=#990000>b</FONT></TD>
& U( K0 k1 a; t4 f& ]<TD align=middle width="25%"><FONT color=#990000>BOS</FONT></TD></TR></TABLE>5 G% I+ F+ \# o: T1 C
<>　　因为x86CPU是little-endian，值0x0042在内存中的存储形式是42 00。你能看出如果这个字符串被传给strlen()函数会出现什么问题吗？它将先看到第一个字节42，然后是00，而00是字符串结束的标志，于是strlen()将会返回1。如果把"Bob"传给wcslen()，将会得出更坏的结果。wcslen()将会先看到0x6f42，然后是0x0062，然后一直读到你的缓冲区的末尾，直到发现00 00结束标志或者引起了GPF。" y7 S- [$ g( A. J! y4 E7 d7 D/ j* S7 ^
　　到目前为止，我们已经讨论了str***()和wcs***()的用法及它们之间的区别。Str***()和_mbs**()之间的有区别区别呢？明白他们之间的区别，对于采用正确的方法来遍历DBCS字符串是很重要的。下面，我们将先介绍字符串的遍历，然后回到str***()与_mbs***()之间的区别这个问题上来。
. P; Y- Q' n1 p2 s" p; b+ W$ A0 ~. F' n6 R  @, S# j! i- q/ m) X
<IMG src="http://www.vckbase.com/document/image/paragraph.gif"> <B>正确的遍历和索引字符串</B>
/ b4 ^$ L) V- H! o+ _; j- A
, I0 K) p! c' [- K/ `$ V　　因为我们中大多数人都是用着SBCS字符串成长的，所以我们在遍历字符串时，常常使用指针的++-和-操作。我们也使用数组下标的表示形式来操作字符串中的字符。这两种方式是用于SBCS和Unicode字符串，因为它们中的字符有着相同的宽度，编译器能正确的返回我们需要的字符。! a: Z% G# y1 b
　　然而，当碰到DBCS字符串时，我们必须抛弃这些习惯。这里有使用指针遍历DBCS字符串时的两条规则。违背了这两条规则，你的程序就会存在DBCS有关的bugs。</P>
  d9 P/ m; @- `' P* u<DIR>- }& n0 Z! T( t- A" P) @- O
<LI>1．在前向遍历时，不要使用++操作，除非你每次都检查lead byte；
8 e8 t# v" T* n1 h# l, C% }<LI>2．永远不要使用-操作进行后向遍历。 </LI></DIR>
8 c# C2 @5 @/ `- P  K+ q$ a<>　　我们先来阐述规则2，因为找到一个违背它的真实的实例代码是很容易的。假设你有一个程序在你自己的目录里保存了一个设置文件，你把安装目录保存在注册表中。在运行时，你从注册表中读取安装目录，然后合成配置文件名，接着读取该文件。假设，你的安装目录是C:\Program Files\MyCoolApp，那么你合成的文件名应该是C:\Program Files\MyCoolApp\config.bin。当你进行测试时，你发现程序运行正常。
* Z' p# w% k9 H+ o　　现在，想象你合成文件名的代码可能是这样的：</P><RE>bool GetConfigFileName ( char* pszName, size_t nBuffSize )4 a8 ~7 v9 Z  `/ c# L% Q
{2 k/ _# G5 G9 y8 X8 x, Z
    char szConfigFilename[MAX_PATH];
# A1 k/ q- x2 v2 A' ` 7 J+ p3 m- B# z( J8 X
    // Read install dir from registry... we''ll assume it succeeds.3 t+ H* X- z; w+ r) p( k

! ~- j- z! w) t+ o8 o% O    // Add on a backslash if it wasn''t present in the registry value.& `: I# o1 Y& d% U' X, L
    // First, get a pointer to the terminating zero.) H; Y, z. w# w6 h& W; A' g; t
    char* pLastChar = strchr ( szConfigFilename, ''\0'' );# k( E4 y! @  y6 n% W2 \4 w
$ P# w9 N6 B) R' Q1 F- C& j, T
    // Now move it back one character.: v" I" O: E" ]0 ^# q( {$ _/ @3 ]
    pLastChar--;  
0 j" t& u  l3 u! Y/ ^
) o- g3 a( @# A& U    if ( *pLastChar != ''\\'' )- V; X5 b, r$ {4 K% W% p. E# y
        strcat ( szConfigFilename, "\\" );; O7 R0 m2 f/ Y3 V6 ~' W% U
4 s. D: R5 q! p* J: B7 \
    // Add on the name of the config file.
, e& H+ K$ ?$ P* F) e) }    strcat ( szConfigFilename, "config.bin" );2 l8 ~4 J0 ^$ v" J+ E

' W: j7 ?# @# T    // If the caller''s buffer is big enough, return the filename.( @* ~0 i8 O( a( Z  c5 J
    if ( strlen ( szConfigFilename ) &gt;= nBuffSize )% u6 r! [6 o# W
        return false;
+ v3 ]2 P2 q, E, ~# g+ M    else
. {; w9 z; z" @/ W) l2 u- T2 T, p- E. C        {- W# G# `! p* n8 \4 n; Z5 i
        strcpy ( pszName, szConfigFilename );7 Q- {% D  E! ?$ ~, N! z8 V$ e
        return true;  Z( I+ I2 {' D! o) \& ~4 g
        }
( n- l8 x* u; S6 T5 Q; B0 J}      </PRE>　　这是一段很健壮的代码，然而在遇到 DBCS 字符时它将会出错。让我们来看看为什么。假设一个日本用户使用了你的程序，把它安装在 C:\<IMG src="http://www.vckbase.com/document/journal/vckbase30/images/youkoso.gif" border=0>。下面是这个名字在内存中的存储形式：
/ F" l: ?% P( O, t　 & N3 q7 T" s9 W' ]$ x; H
<TABLE>% l& J% @6 H) z( J5 J

) f! s0 V! q7 g) p<TR>
  }& o! c4 D0 u4 ~# L9 y3 A<TD align=middle width="12%">43</TD>
5 v2 k% ^& s* Y<TD align=middle width="12%"><FONT color=#990000>3A</FONT></TD>
6 m  b2 A. u" ]1 b<TD align=middle width="12%"><FONT color=#0000ff>5C</FONT></TD>
$ x: M0 t& N$ d% T  o  Z<TD align=middle width="12%">83 88</TD>3 c: X9 J9 V& k" r5 V3 p; u# Q
<TD align=middle width="13%">83 45</TD>
7 P, b; r4 I* n6 s, Y9 l<TD align=middle width="13%">83 52</TD>
: N* ?6 W2 i$ h, S<TD align=middle width="13%">83 <FONT color=#0000ff>5C</FONT></TD>' T# I1 T: l: Q( t
<TD align=middle width="13%">00</TD></TR>
- ]; q0 ~) Y8 d8 S* z+ M<TR>5 r  v3 O; `) U4 i2 w
<TD align=middle width="12%">　</TD>3 u: m2 P  T( g  `. G$ n3 `/ b
<TD align=middle width="12%">　</TD>
# R* O/ N' d  C  h7 ^9 l<TD align=middle width="12%">　</TD>9 L7 N) ?6 O  q! q
<TD align=middle width="12%"><FONT color=#990000>LB TB </FONT></TD>& p4 H( J7 w) q  u+ M7 N. X: b3 N
<TD align=middle width="13%"><FONT color=#990000>LB TB </FONT></TD>2 k8 X7 T/ V7 r9 v3 _; l8 `  m
<TD align=middle width="13%"><FONT color=#990000>LB TB </FONT></TD>
  {; o5 e) r% @4 R<TD align=middle width="13%"><FONT color=#990000>LB TB </FONT></TD>
+ A; z/ O8 g9 {4 t8 q9 I<TD align=middle width="13%">　</TD></TR>
5 P- b. Q3 A/ e7 J<TR>5 N# z3 |) R0 `& i3 m3 L# @
<TD align=middle width="12%">C</TD>
% ?. Z# Y1 {$ \" _  e4 J<TD align=middle width="12%">:</TD>8 z  ?% [7 W% T9 K( ]* v
<TD align=middle width="12%">\</TD>  T- r, |( L4 W
<TD align=middle width="12%"><IMG src="http://www.vckbase.com/document/journal/vckbase30/images/yo.gif" border=0></TD>0 G2 L* p0 v! @  Y0 M
<TD align=middle width="13%"><IMG src="http://www.vckbase.com/document/journal/vckbase30/images/u.gif" border=0></TD>
) o6 @4 C. d' d* i. W<TD align=middle width="13%"><IMG src="http://www.vckbase.com/document/journal/vckbase30/images/ko.gif" border=0></TD>! N" ~& P) `+ G/ r; ]# ^
<TD align=middle width="13%"><IMG src="http://www.vckbase.com/document/journal/vckbase30/images/so.gif" border=0></TD>' H% W/ g" _* E. c, u
<TD align=middle width="13%">EOS</TD></TR></TABLE>) M3 Z6 @- w- \0 A* P# L! l
<>　　当使用 GetConfigFileName() 检查尾部的''\\''时，它寻找安装目录名中最后的非0字节，看它是等于''\\''的，所以没有重新增加一个''\\''。结果是代码返回了错误的文件名。- S( z% V2 z6 f3 F, T
　　哪里出错了呢？看看上面两个被用蓝色高量显示的字节。斜杠''\\''的值是0x5c。'' ''的值是83 5c。上面的代码错误的读取了一个 trail byte，把它当作了一个字符。
1 m, h. D/ h8 y* O, D　　正确的后向遍历方法是使用能够识别DBCS字符的函数，使指针移动正确的字节数。下面是正确的代码。（指针移动的地方用红色标明） </P><RE>bool FixedGetConfigFileName ( char* pszName, size_t nBuffSize )' x. R  |" O2 s# o9 h3 V- `  T
{: a0 C1 H2 |: k7 s6 Q
    char szConfigFilename[MAX_PATH];' f  Z+ Q7 s& e9 c( o
) Y: s  P% }1 U' A: M- K. s
    // Read install dir from registry... we''ll assume it succeeds.
# g# h7 N' p' P% r0 y : v1 k1 B3 I# q8 B  K5 r$ V  x
    // Add on a backslash if it wasn''t present in the registry value.
8 X6 C5 {* V2 p    // First, get a pointer to the terminating zero.
9 A( u( Q0 _1 K    char* pLastChar = _mbschr ( szConfigFilename, ''\0'' );7 o/ R4 `2 h& {9 q# W
& ~. {* z, g" K7 O/ v  N+ l; p% Y
    // Now move it back one double-byte character.
3 x2 ]9 h& [5 ^  <FONT color=#ff0000>  pLastChar = CharPrev ( szConfigFilename, pLastChar );</FONT>0 Z0 E; b! h, k* s/ ?
: d8 c1 e3 d8 k! s
    if ( *pLastChar != ''\\'' )
& ]* p( S. F' n; Q8 F        _mbscat ( szConfigFilename, "\\" );
: v, ]1 d" p& y- g: M- n
' ^/ l8 F! ]- r5 G4 p    // Add on the name of the config file.
! u: ~- d) x, Q$ a  P7 x$ L    _mbscat ( szConfigFilename, "config.bin" );, _; B, X+ u/ }4 i/ n4 n  u- `
; p# k; L" R9 ?# d8 p  k
     // If the caller''s buffer is big enough, return the filename.
! [6 Z3 L7 |8 b& ~    if ( _mbslen ( szInstallDir ) &gt;= nBuffSize )* @) i( |5 f# m) B5 S; k
        return false;2 ]2 V+ e2 |( w* h* D* ^) \& ~
    else
+ Z8 V! f0 W: m% p& B* H        {
& g4 F( `( U  _( D5 E8 s        _mbscpy ( pszName, szConfigFilename );
# B/ q& @6 U  i# t0 p" L. u        return true;( z" w7 x4 @' i
        }% I/ Y% m  l6 f* g% U% V
}
5 ?. B" k# R8 \; j4 W# y( p4 {+ h4 m</PRE>　　上面的函数使用CharPrev() API使pLastChar向后移动一个字符，这个字符可能是两个字节长。在这个版本里，if条件正常工作，因为lead byte永远不会等于0x5c。/ f( W) Q7 f( ^5 B& m5 ?1 y& s* u
　　让我们来想象一个违背规则1的场合。例如，你可能要检测一个用户输入的文件名是否多次出现了'':''。如果，你使用++操作来遍历字符串，而不是使用CharNext()，你可能会发出不正确的错误警告如果恰巧有一个trail byte它的值的等于'':''的值。2 [2 a5 m; `$ l9 X9 t+ a: |$ \
与规则2相关的关于字符串索引的规则：<RE>2a. 永远不要使用减法去得到一个字符串的索引。</PRE>
( U' [, b6 |7 V  r6 A5 D<>违背这条规则的代码和违背规则2的代码很相似。例如，</P><RE>char* pLastChar = &amp;szConfigFilename [strlen(szConfigFilename) - 1];</PRE>4 T" O- c' s% U& i: o7 s
<>这和向后移动一个指针是同样的效果。
( {9 U  a( I) b8 g5 f. r' J$ J/ [
<IMG src="http://www.vckbase.com/document/image/paragraph.gif"><B> 回到关于str***()和_mbs***()的区别</B>
1 v2 G2 q$ n% [6 K* D: }7 e8 q( H* P/ C
& T$ S" h% @* T! j4 l# x% I" b( v　　现在，我们应该很清楚为什么_mbs***()函数是必需的。Str***()函数根本不考虑DBCS字符，而_mbs***()考虑。如果，你调用strrchr("C:\\ ", ''\\'')，返回结果可能是错误的，然而_mbsrchr()将会认出最后的双字节字符，返回一个指向真的''\\''的指针。
; [3 i3 j9 C$ ^' A0 e　　关于字符串函数的最后一点：str***()和_mbs***()函数认为字符串的长度都是以char来计算的。所以，如果一个字符串包含3个双字节字符，_mbslen()将会返回6。Unicode函数返回的长度是按wchar_t来计算的。例如，wcslen(L"Bob")返回3。7 }/ H3 Q9 Z) k

( a# a% Y" {' N* @1 h7 F<IMG src="http://www.vckbase.com/document/image/paragraph.gif"><B> Win32 API中的MBCS和Unicode</B>
+ @$ m4 H  Y8 E  {+ Z7 k$ C" U
' D5 U  Q6 ~8 }: g/ Q' j两组 APIs：
" W- y  O0 E1 N7 M　　尽管你也许从来没有注意过，Win32中的每个与字符串相关的API和message都有两个版本。一个版本接受MBCS字符串，另一个接受Unicode字符串。例如，根本没有SetWindowText()这个API，相反，有SetWindowTextA()和SetWindowTextW()。后缀A表明这是MBCS函数，后缀W表示这是Unicode版本的函数。1 I: b3 J* T7 L$ L3 L
　　当你 build 一个 Windows 程序，你可以选择是用 MBCS 或者 Unicode APIs。如果，你曾经用过VC向导并且没有改过预处理的设置，那表明你用的是MBCS版本。那么，既然没有 SetWindowText() API，我们为什么可以使用它呢？winuser.h头文件包含了一些宏，例如： </P><RE>BOOL WINAPI SetWindowTextA ( HWND hWnd, LPCSTR lpString );# I; q, f1 P3 F
BOOL WINAPI SetWindowTextW ( HWND hWnd, LPCWSTR lpString );, f. ~2 ~2 M3 ]4 L0 E

: d. W" \* K* L5 E2 E5 E- P3 g4 ^#ifdef UNICODE  W: t( Q- h# q  r( H
#define SetWindowText  SetWindowTextW4 ~+ g+ Q* ?/ S+ i$ T
#else1 u7 _6 N, E% z
#define SetWindowText  SetWindowTextA6 e8 \$ Q- E* L4 ~: |8 h0 @, N
#endif      </PRE>当使用MBCS APIs来build程序时，UNICODE没有被定义，所以预处理器看到：<RE>#define SetWindowText SetWindowTextA</PRE>
; m( C+ K: @, e8 @5 g1 W$ i<>　　这个宏定义把所有对SetWindowText的调用都转换成真正的API函数SetWindowTextA。（当然，你可以直接调用SetWindowTextA() 或者 SetWindowTextW()，虽然你不必那么做。）# N; ^. G8 L! E1 V2 r2 N! D) h
　　所以，如果你想把默认使用的API函数变成Unicode版的，你可以在预处理器设置中，把_MBCS从预定义的宏列表中删除，然后添加UNICODE和_UNICODE。(你需要两个都定义，因为不同的头文件可能使用不同的宏。) 然而，如果你用char来定义你的字符串，你将会陷入一个尴尬的境地。考虑下面的代码：</P><RE>HWND hwnd = GetSomeWindowHandle();# `% K" P: v+ |  y
char szNewText[] = "we love Bob!";3 Q( {! I/ a4 c- k8 N
SetWindowText ( hwnd, szNewText );</PRE>2 B, i' |* u, A6 U) X1 K' I. ?5 T& T
<>在预处理器把SetWindowText用SetWindowTextW来替换后，代码变成：</P><RE>HWND hwnd = GetSomeWindowHandle();( N$ i7 B7 y. B
char szNewText[] = "we love Bob!";) g/ C  ~) |# \9 o, u1 a$ ^
SetWindowTextW ( hwnd, szNewText );</PRE>
( V$ v4 \1 D6 t5 c, |# e0 ~<>　　看到问题了吗？我们把单字节字符串传给了一个以Unicode字符串做参数的函数。解决这个问题的第一个方案是使用 #ifdef 来包含字符串变量的定义：</P><RE>HWND hwnd = GetSomeWindowHandle();
; S; W  n- b. U) ]#ifdef UNICODE# P! v; I- ~: m; h: b* i$ n
wchar_t szNewText[] = L"we love Bob!";) R) F5 K3 h" i$ F
#else
8 }. u" l0 G' U; j  W. echar szNewText[] = "we love Bob!";5 c9 [) C5 F* Y7 U
#endif% {) a9 K" I# j$ x0 M
SetWindowText ( hwnd, szNewText );</PRE>3 Q" z# S, S1 u# z& M
<>你可能已经感受到了这样做将会使你多么的头疼。完美的解决方案是使用TCHAR.
6 b: ^' ~. [0 {2 {+ s
( I1 p- [$ E% b* {, e' f9 u# a<IMG src="http://www.vckbase.com/document/image/paragraph.gif"><B> 使用TCHAR</B>
2 a  v6 E; M4 l( p% [  D+ G& m4 [# Q
　　TCHAR是一种字符串类型，它让你在以MBCS和UNNICODE来build程序时可以使用同样的代码，不需要使用繁琐的宏定义来包含你的代码。TCHAR的定义如下：</P><RE>#ifdef UNICODE1 |4 k1 V' ?& y: c9 O( v
typedef wchar_t TCHAR;
. r7 V8 p9 P# D#else
) z" L6 A7 S4 `) dtypedef char TCHAR;
/ E: }5 y( Q% _# p0 n, T#endif</PRE>. J( D% @8 S1 X% k  ]: U' U3 Z' m
<>所以用MBCS来build时，TCHAR是char，使用UNICODE时，TCHAR是wchar_t。还有一个宏来处理定义Unicode字符串常量时所需的L前缀。</P><RE>#ifdef UNICODE
! R, Y* g, I2 `1 |. }+ A' m#define _T(x) L##x- c' t( D4 Z. y  V; Y' C
#else
3 @. `8 E! R5 X! X* t+ W! P#define _T(x) x
+ z+ n5 F. \3 o0 {5 L: ^#endif</PRE>
& J( ]9 _" X" }6 @( C( A- G<P>　　##是一个预处理操作符，它可以把两个参数连在一起。如果你的代码中需要字符串常量，在它前面加上_T宏。如果你使用Unicode来build，它会在字符串常量前加上L前缀。</P><PRE>TCHAR szNewText[] = _T("we love Bob!");</PRE>% B; I3 e" {, Y8 w( J# P- W3 t
<P>　　像是用宏来隐藏SetWindowTextA/W的细节一样，还有很多可以供你使用的宏来实现str***()和_mbs***()等字符串函数。例如，你可以使用_tcsrchr宏来替换strrchr()、_mbsrchr()和wcsrchr()。_tcsrchr根据你预定义的宏是_MBCS还是UNICODE来扩展成正确的函数，就像SetWindowText所作的一样。! X* f  @8 U7 k- u7 i, n' U5 D
　　不仅str***()函数有TCHAR宏。其他的函数如， _stprintf（代替sprinft()和swprintf()）,_tfopen（代替fopen()和_wfopen()）。 MSDN中"Generic-Text Routine Mappings."标题下有完整的宏列表。
2 X- L' ~6 F2 ?, g4 f+ M4 i7 ~0 w/ _. Y% g2 f$ N5 q3 }
<IMG src="http://www.vckbase.com/document/image/paragraph.gif"><B> 字符串和TCHAR typedefs</B>
( w" I9 ?1 }1 y6 H7 G0 x9 a, W, |! {1 U3 Z! K  D" P; c& {
　　由于Win32 API文档的函数列表使用函数的常用名字（例如，"SetWindowText"），所有的字符串都是用TCHAR来定义的。（除了XP中引入的只适用于Unicode的API）。下面列出一些常用的typedefs，你可以在msdn中看到他们。</P>8 E+ M' G3 Z9 {' J% W  M! a
<TABLE>
6 J1 V6 T& u- V, o1 B/ F! i$ a. u5 v! r6 m- b6 p
<TR>
/ }+ x% g3 ~( G5 E- Q1 X) F6 Z<TD align=middle width="16%"><B>type </B></TD>& X3 @* m+ |2 o3 b! t
<TD align=middle width="42%"><B>Meaning in MBCS builds </B></TD>' L  V  i7 M( c3 _
<TD align=middle width="42%"><B>Meaning in Unicode builds</B></TD></TR>5 w7 O) ^" G9 X& }* B; K/ t, G
<TR>
" s7 C" j* k" Y<TD width="16%">WCHAR</TD>7 L, {9 l$ N- ?# T/ z& p3 v
<TD width="42%">wchar_t</TD>& Z8 ~; B5 U! Y5 C9 V
<TD width="42%">wchar_t</TD></TR>. }( \) a0 e7 f
<TR>
7 L0 U2 H1 F# b" k) R<TD width="16%">LPSTR </TD>7 d  V9 x" Y1 q: P9 F- k& p
<TD width="42%">zero-terminated string of char (char*)</TD>
4 j; a& z+ {8 F<TD width="42%">zero-terminated string of char (char*)</TD></TR>
( c- j) I$ W% `<TR>: ]7 i% Z1 T8 t2 s& r) W
<TD width="16%">LPCSTR </TD>
* `6 }* X1 u4 \$ S% ^( v<TD width="42%">constant zero-terminated string of char (const char*)</TD>, G) ^1 o; w7 }( I. ^" {& ?
<TD width="42%">constant zero-terminated string of char (const char*)</TD></TR>
" R' {0 e% E! B- B# K$ v, \4 q<TR>
7 R7 M" Y. i  M1 Q  Y- Q- T$ C<TD width="16%">LPWSTR</TD>
) E* K# b& g/ b) D  l; f<TD width="42%">zero-terminated Unicode string (wchar_t*) </TD>
8 F- `, q" n& W% Z" y<TD width="42%">zero-terminated Unicode string (wchar_t*)</TD></TR>! C1 x- y0 O  N
<TR>& S- @  j! v% |/ A5 W0 q
<TD width="16%">LPCWSTR</TD>/ U; |6 }9 W" Q" }6 R- V% L
<TD width="42%">constant zero-terminated Unicode string (const wchar_t*)</TD>
4 w+ y- u/ W- A0 G, y# F<TD width="42%">constant zero-terminated Unicode string (const wchar_t*) </TD></TR>
5 x0 g7 o) z) l( b0 x' b& t3 I<TR>
  x$ n8 a3 l& T' g0 X<TD width="16%"><XXXXIME xime="7">TCHAR</XXXXIME></TD>
7 \3 r+ Y( o/ R<TD width="42%"><XXXXIME xime="7">char</XXXXIME></TD>: l) s& ^  r8 C. |0 U
<TD width="42%"><XXXXIME xime="7">wchar_t</XXXXIME></TD></TR>
) R1 H; W) r6 T9 M. {<TR>* e% w+ }! W# P* R3 _
<TD width="16%">LPTSTR</TD>
7 M) t& g% S" T- h% M! Y; N<TD width="42%">zero-terminated string of TCHAR (TCHAR*) </TD>9 {9 e6 ~6 c% k
<TD width="42%">zero-terminated string of TCHAR (TCHAR*)</TD></TR>
( s% b5 p* [: P0 ]; w<TR>+ e! ]8 w- E; k  W1 {
<TD width="16%">LPCTSTR </TD>
. }) @, U+ Z- T9 a3 m<TD width="42%">constant zero-terminated string of TCHAR (const TCHAR*)</TD>
! f5 y3 T2 P: J7 C5 R8 P* U) i9 e<TD width="42%">constant zero-terminated string of TCHAR (const TCHAR*)</TD></TR></TABLE>- j1 V9 X* s2 z
<P><IMG src="http://www.vckbase.com/document/image/paragraph.gif"><B> 何时使用 TCHAR 和 Unicode</B>$ A4 X; X8 o) K0 B& Y

8 W3 o. T; ^1 O: l, S* L: a' k9 l　　到现在，你可能会问，我们为什么要使用Unicode。我已经用了很多年的char。下列3种情况下，使用Unicode将会使你受益：</P>  L. @$ g  E4 k5 @* w" D+ x, P2 _
<DIR>. J' A8 }9 H# Q, _4 |- Q' w& I
<LI>1．你的程序只运行在Windows NT系统中。 9 l, n4 `9 B1 z! }% G$ r0 F
<LI>2． 你的程序需要处理超过MAX_PATH个字符长的文件名。
- [6 k4 f6 Z# G% K9 @<LI>3． 你的程序需要使用XP中引入的只有Unicode版本的API. </LI></DIR>
  O8 @) t3 ?5 S  B<P>　　Windows 9x 中大多数的 API 没有实现 Unicode 版本。所以，如果你的程序要在windows 9x中运行，你必须使用MBCS APIs。然而，由于NT系统内部都使用Unicode，所以使用Unicode APIs将会加快你的程序的运行速度。每次，你传递一个字符串调用MBCS API，操作系统会把这个字符串转换成Unicode字符串，然后调用对应的Unicode API。如果一个字符串被返回，操作系统还要把它转变回去。尽管这个转换过程被高度优化了，但它对速度造成的损失是无法避免的。; x+ R* {2 F* J8 `( [/ ?  b2 g
　　只要你使用Unicode API，NT系统允许使用非常长的文件名（突破了MAX_PATH的限制，MAX_PATH=260）。使用Unicode API的另一个优点是你的程序会自动处理用户输入的各种语言。所以一个用户可以输入英文，中文或者日文，而你不需要额外编写代码去处理它们。- F" R+ r' ?  S# P& d0 l
　　最后，随着windows 9x产品的淡出，微软似乎正在抛弃MBCS APIs。例如，包含两个字符串参数的SetWindowTheme() API只有Unicode版本的。使用Unicode来build你的程序将会简化字符串的处理，你不必在MBCS和Unicdoe之间相互转换。
7 o1 q5 B: w& N　　即使你现在不使用Unicode来build你的程序，你也应该使用TCHAR及其相关的宏。这样做不仅可以的代码可以很好地处理DBCS，而且如果将来你想用Unicode来build你的程序，你只需要改变一下预处理器中的设置就可以实现了。
- J* _9 E* y& B& X/ @1 ?( m# J+ `( {7 H9 j
</P>
$ p, p! F3 ?; T3 N
& I5 n( s' V* B5 A4 O6 U/ k& z" d
<p>& H2 T9 O" B1 H, b6 U* `9 G: @5 n
<p></TD></TR>4 g5 X9 S- s6 ^' Y# e% b& ^
<TR>
; H- j- H& T: E  d<TD><IMG src="http://www.vckbase.com/document/image/paragraph.gif"><B> 作者简介</B>0 J% V/ G5 B) s! \+ k
　　Michael Dunn：居住在阳光城市洛杉矶。他是如此的喜欢这里的天气以致于想一生都住在这里。他在4年级时开始编程，那时用的电脑是Apple //e。1995年，在 UCLA 获得数学学士学位，随后在Symantec 公司做 QA 工程师，在 Norton AntiVirus 组工作。他自学了 Windows 和 MFC 编程。1999-2000年，他设计并实现了 Norton AntiVirus 的新界面。　
' n1 J2 g, Q+ m; g　　Michael 现在在 Napster（一个提供在线订阅音乐服务的公司）做开发工作，他还开发了UltraBar，一个IE工具栏插件，它可以使网络搜索更加容易，给了 googlebar 以沉重打击；他还开发了 CodeProject SearchBar；与人共同创建了 Zabersoft 公司，该公司在洛杉矶和丹麦的 Odense 都设有办事处。
$ L' V: \" m$ w5 m5 x5 N, t* E　　他喜欢玩游戏。爱玩的游戏有 pinball, bike riding，偶尔还玩 PS, Dreamcasth 和 MAME 游戏。他因忘了自己曾经学过的语言：法语、汉语、日语而感到悲哀。</TD></TR></TABLE></P>



欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5