MultiByteToWideChar, WideCharToMultiByte

 

MultiByteToWideChar

    const UINT codePage = 936;                              // GB 2312.
    CCHAR *multiByteString = "源字符串abcd";

    // First: get count of multi-byte string.
    const DWORD cCh = MultiByteToWideChar(codePage,         // Character Page.
                                          0,                // Flag, always be 0.
                                          multiByteString,  // Multi-byte string.
                                          -1,               // '-1' is to determind length automatically.
                                          NULL,             // 'NULL' means ignore result. This is based
                                                            // on next argument is '0'.
                                          0);               // '0' is to get the count of character needed 
                                                            // instead of to translate.

    // Second: allocate enough memory to save result in wide character.
    PWCHAR pWideCharString = new WCHAR[cCh];
    ZeroMemory(pWideCharString, cCh * sizeof(pWideCharString[0]));

    // Third: Translate it!
    MultiByteToWideChar(codePage,                           // Character Page.
                        0,                                  // Flag, always be 0.
                        multiByteString,                    // Multi-byte string.
                        -1,                                 // Count of character of string above.
                        pWideCharString,                    // Target wide character buffer.
                        cCh);                               // Count of character of wide character string buffer.

    // Fourth: use it!
    // ...

    // Fifth: deallocate the memory.
    delete pWideCharString;
    pWideCharString = NULL;

 

 

WideCharToMultiByte

    const UINT codePage = 936;                              // GB 2312.
    WCHAR *wideCharString = L"源字符串abcd";

    // First: get count.
    const DWORD cCh = WideCharToMultiByte(codePage,            
                                          0,
                                          wideCharString, 
                                          -1,
                                          NULL,
                                          0,
                                          NULL,             // When the wide character to be traslated
                                                            // is not in code page, proc will use this 
                                                            // variable to fill with. We usually set it
                                                            // to NULL.
                                          NULL);            // This variable will save the number of 
                                                            // character which can't be tranlated. We
                                                            // usually set it to NULL.

    // Second: allocate enough memory to save result.
    PCHAR pMultiByteString = new CHAR[cCh];
    ZeroMemory(pMultiByteString, cCh * sizeof(pMultiByteString[0]));

    // Third: Translate it!
    WideCharToMultiByte(codePage,
                        0,
                        wideCharString,
                        -1,
                        pMultiByteString,
                        cCh,
                        NULL,
                        NULL);

    // Fourth: use it!
    // ...

    // Fifth: deallocate the memory.
    delete pMultiByteString;
    pMultiByteString = NULL;

 

转载于:https://www.cnblogs.com/walfud/archive/2012/07/06/2579487.html