3、使用ANSI/Unicode通用數據類型

　　微軟提供了一些ANSI和Unicode兼容的通用數據類型，我們最常用的數據類型有_T ，TCHAR，LPTSTR,LPCTSTR。
　　順便說一下，LPCTSTR和const TCHAR*是完全等同的。其中L表示long指針，這是為了兼容Windows 3.1等16位操作系統遺留下來的，在Win32 中以及其它的32位操作系統中，long指針和near指針及far修飾符都是為了兼容的作用，沒有實際意義。P（pointer）表示這是一個指針；C（const）表示是一個常量；T(_T宏)表示兼容ANSI和Unicode，STR（string）表示這個變量是一個字符串。綜上可以看出，LPCTSTR表示一個指向常固定地址的可以根據一些宏定義改變語義的字符串。比如：

    
      TCHAR* szText=_T(“Hello!”);
TCHAR szText[]=_T(“I Love You”);
LPCTSTR lpszText=_T(“大家好！”);

    
  

使用函數中的參數最好也要有變化，比如：

    
      MessageBox(_T(“你好”));
    
  

　　其實，在上面的語句中，即使您不加_T宏，MessageBox函數也會自動把“你好”字符串進行強制轉換。但我還是推薦您使用_T宏，以表示您有Unicode編碼意識。

4、修改字符串運算問題

　　一些字符串操作函數需要獲取字符串的字符數(sizeof(szBuffer)/sizeof(TCHAR))，而另一些函數可能需要獲取字符串的字節數sizeof(szBuffer)。您應該注意該問題并仔細分析字符串操作函數，以確定能夠得到正確的結果。
ANSI操作函數以str開頭，如strcpy()，strcat()，strlen()；
Unicode操作函數以wcs開頭，如wcscpy，wcscpy()，wcslen()；
ANSI/Unicode操作函數以_tcs開頭 _tcscpy(C運行期庫)；
ANSI/Unicode操作函數以lstr開頭 lstrcpy(Windows函數)；
考慮ANSI和Unicode的兼容，我們需要使用以_tcs開頭或lstr開頭的通用字符串操作函數。

六、舉個Unicode編程的例子

第一步：
　　打開VC++6.0，新建基于對話框的工程Unicode，主對話框IDD_UNICODE_DIALOG中加入一個按鈕控件，雙擊該控件并添加該控件的響應函數：

    
      void CUnicodeDlg::OnButton1() 
{
	TCHAR* str1=_T("ANSI和UNICODE編碼試驗");
	m_disp=str1;
	UpdateData(FALSE);
}
    
  

　　添加靜態文本框IDC_DISP，使用ClassWizard給該控件添加CString類型變量m_disp。使用默認ANSI編碼環境編譯該工程，生成Unicode.exe。

第二步：
　　打開“控制面板”，單擊“日期、時間、語言和區域設置”選項，在“日期、時間、語言和區域設置”窗口中繼續單擊“區域和語言選項”選項，彈出“區域和語言選項”對話框。在該對話框中，單擊“高級”標簽，將“非Unicode的程序的語言”選項改為“日語”，單擊“應用”按鈕，如圖四：

圖四

彈出的對話框單擊“是”，重新啟動計算機使設置生效。
運行Unicode.exe程序并單擊“Button1”按鈕，看，靜態文本框出現了亂碼。

第三步：
　　改為Unicode編碼環境編譯該工程，生成Unicode.exe。再次運行Unicode.exe程序并單擊“Button1”按鈕。看到Unicode編碼的優勢了吧。

就說這些吧，祝您好運。

轉載聲明： 本文轉自 http://www.vckbase.com/document/viewdoc/?id=1733

===================================================================

Unicode, MBCS and Generic text mappings

By Chris Maunder

Introduction

In order to allow your programs to be used in international markets it is worth making your application Unicode or MBCS aware. The Unicode character set is a "wide character" (2 bytes per character) set that contains every character available in every language, including all technical symbols and special publishing characters. Multibyte character set (MBCS) uses either 1 or 2 bytes per character and is used for character sets that contain large numbers of different characters (eg Asian language character sets).

Which character set you use depends on the language and the operating system. Unicode requires more space than MBCS since each character is 2 bytes. It is also faster than MBCS and is used by Windows NT as standard, so non-Unicode strings passed to and from the operating system must be translated, incurring overhead. However, Unicode is not supported on Win95 and so MBCS may be a better choice in this situation. Note that if you wish to develop applications in the Windows CE environment then all applications must be compiled in Unicode.

Using MBCS or Unicode

The best way to use Unicode or MBCS - or indeed even ASCII - in your programs is to use the generic text mapping macros provided by Visual C++. That way you can simply use a single define to swap between Unicode, MBCS and ASCII without having to do any recoding.

To use MBCS or Unicode you need only define either _MBCS or _UNICODE in your project. For Unicode you will also need to specify the entry point symbol in your Project settings as wWinMainCRTStartup . Please note that if both _MBCS and _UNICODE are defined then the result will be unpredictable.

Generic Text mappings and portable functions

The generic text mappings replace the standard char or LPSTR types with generic TCHAR or LPTSTR macros. These macros will map to different types and functions depending on whether you have compiled with Unicode or MBCS (or neither) defined. The simplest way to use the TCHAR type is to use the CString class - it is extremely flexible and does most of the work for you.

In conjunction with the generic character type, there is a set of generic string manipulation functions prefixed by _tcs . For instance, instead of using the strrev function in your code, you should use the _tcsrev function which will map to the correct function depending on which character set you have compiled for. The table below demonstrates:

Each str* function has a corresponding tcs* function that should be used instead. See the TCHAR.H file for all the mapping and macros that are available. Just look up the online help for the string function in question in order to find the equivalent portable function.

Note: Do not use the str* family of functions with Unicode strings, since Unicode strings are likely to contain embedded null bytes.

The next important point is that each literal string should be enclosed by the TEXT() (or _T() ) macro. This macro prepends a "L" in front of literal strings if the project is being compiled in Unicode, or does nothing if MBCS or ASCII is being used. For instance, the string _T( " Hello" ) will be interpreted as " Hello" in MBCS or ASCII, and L " Hello" in Unicode. If you are working in Unicode and do not use the _T() macro, you may get compiler warnings.

Note that you can use ASCII and Unicode within the same program, but not within the same string.

All MFC functions except for database class member functions are Unicode aware. This is because many database drivers themselves do not handle Unicode, and so there was no point in writing Unicode aware MFC classes to wrap these drivers.

Converting between Generic types and ASCII

ATL provides a bunch of very useful macros for converting between different character format. The basic form of these macros is X2Y() , where X is the source format. Possible conversion formats are shown in the following table.

Thus, A2W converts an LPSTR to an LPWSTR , OLE2T converts an LPOLESTR to an LPTSTR , and so on.

There are also const forms (denoted by a C ) that convert to a const string. For instance, A2CT converts from LPSTR to LPCTSTR .

When using the string conversion macros you need to include the USES_CONVERSION macro at the beginning of your function:

Collapse Copy Code

    
      void
    
     foo(LPSTR lpsz)
{
   USES_CONVERSION;
   
   ...
   LPTSTR szGeneric = A2T(lpsz)
   
    
      //
    
    
       Do something with szGeneric

    
       ...
}

  

Two caveats on using the conversion macros:

1. Never use the conversion macros inside a tight loop. This will cause a lot of memory to be allocated each time the conversion is performed, and will result in slow code. Better to perform the conversion outside the loop and pass the converted value into the loop.
2. Never return the result of the macros directly from a function, unless the return value implies making a copy of the data before returning. For instance, if you have a function that returns an LPOLESTR, then do not do the following:
   Collapse Copy Code

           LPTSTR BadReturn(LPSTR lpsz)
   {
       USES_CONVERSION;
       
           
             //
           
           
              do something
   
           
           
             return
           
            A2T(lpsz);
   }
         

   Instead, you should return the value as a CString, which would imply a copy of the string would be made before the function returns:

   Collapse Copy Code

           CString GoodReturn(LPSTR lpsz)
   {
       USES_CONVERSION;
       
           
             //
           
           
              do something
   
           
           
             return
           
            A2T(lpsz);
   }
         

Tips and Traps

The TRACE statement

The TRACE macros have a few cousins - namely the TRACE0 , TRACE1 , TRACE2 and TRACE3 macros. These macros allow you to specify a format string (as in the normal TRACE macro), and either 0,1,2 or 3 parameters, without the need to enclose your literal format string in the _T() macro. For instance,

Collapse Copy Code

    TRACE(_T(
    
      "
    
    
      This is trace statement number %d/n"
    
    ), 
    
      1
    
    );
  

can be written

Collapse Copy Code

    TRACE1(
    
      "
    
    
      This is trace statement number %d/n"
    
    , 
    
      1
    
    );
  

Viewing Unicode strings in the debugger

If you are using Unicode in your applciation and wish to view Unicode strings in the debugger, then you will need to go to Tools | Options | Debug and click on "Display Unicode Strings".

The Length of strings

Be careful when performing operations that depend on the size or length of a string. For instance, CString::GetLength returns the number of characters in a string, NOT the size in bytes. If you were to write the string to a CArchive object, then you would need to multiply the length of the string by the size of each character in the string to get the number of bytes to write:

Collapse Copy Code

    CString str = _T(
    
      "
    
    
      Hello, World"
    
    );
archive.Write( str, str.GetLength( ) * 
    
      sizeof
    
    ( TCHAR ) ); 
  

Reading and Writing ASCII text files

If you are using Unicode or MBCS then you need to be careful when writing ASCII files. The safest and easiest way to write text files is to use the CStdioFile class provided with MFC. Just use the CString class and the ReadString and WriteString member functions and nothing should go wrong. However, if you need to use the CFile class and it's associated Read and Write functions, then if you use the following code:

Collapse Copy Code

    CFile file(...); 
CString str = _T(
    
      "
    
    
      This is some text"
    
    ); 
file.Write( str, (str.GetLength()+1) * 
    
      sizeof
    
    ( TCHAR ) ); 
  

instead of

Collapse Copy Code

    CStdioFile file(...); 
CString str = _T(
    
      "
    
    
      This is some text"
    
    ); 
file.WriteString(str); 
  

then the results will be Significantly different. The two lines of text below are from a file created using the first and second code snippets respectively:

(This text was viewed using WordPad)

Not all structures use the generic text mappings

For instance, the CHARFORMAT structure, if the RichEditControl version is less than 2.0, uses a char [] for the szFaceName field, instead of a TCHAR as would be expected. You must be careful not to blindly change "..." to _T( " ..." ) without first checking. In this case, you would probably need to convert from TCHAR to char before copying any data to the szFaceName field.

Copying text to the Clipboard

This is one area where you may need to use ASCII and Unicode in the same program, since the CF_TEXT format for the clipboard uses ASCII only. NT systems have the option of the CF_UNICODETEXT if you wish to use Unicode on the clipboard.

Installing the Unicode MFC libraries

The Unicode versions of the MFC libraries are not copied to your hard drive unless you select them during a Custom installation. They are not copied during other types of installation. If you attempt to build or run an MFC Unicode application without the MFC Unicode files, you may get errors.

(From the online docs) To copy the files to your hard drive, rerun Setup, choose Custom installation , clear all other components except "Microsoft Foundation Class Libraries," click the Details button, and select both "Static Library for Unicode" and "Shared Library for Unicode."

License

About the Author

• Member Function Pointers and the Fastest Possible C++ Delegates
  A comprehensive tutorial on member function pointers, and an implementation of delegates that generates only two ASM opcodes!
• How a C++ compiler implements exception handling
  An indepth discussion of how VC++ implements exception handling. Source code includes exception handling library for VC++.
• A Beginner's Guide to Pointers
  An article showing the use of pointers in C and C++
• XML class for processing and building simple XML documents
  Link CMarkup into your VC++ app and avoid complex XML tools and dependencies
• PugXML - A Small, Pugnacious XML Parser
  Discussion of techniques for fast, robust, light-weight XML parsing.

Shared links ： http://www.codeproject.com/KB/cpp/unicode.aspx

VC++的Unicode編程（經典之作，交流傳薪）