¿Cómo se utiliza adecuadamente WideCharToMultiByte

Question

He leído la documentación sobre WideCharToMultiByte, pero estoy atascado en este parámetro:

lpMultiByteStr 
[out] Pointer to a buffer that receives the converted string. 

No estoy muy seguro de cómo inicializar correctamente la variable y se alimentan en la función

Answer 1

Utiliza el parámetro lpMultiByteStr [out] creando una nueva matriz de caracteres. A continuación, pasa esta matriz de caracteres para que se llene. Solo necesita inicializar la longitud de la cadena + 1 para que pueda tener una cadena con terminación nula después de la conversión.

Aquí hay un par de útiles funciones de ayuda para usted, que muestran el uso de todos los parámetros.

#include <string> 

std::string wstrtostr(const std::wstring &wstr) 
{ 
    // Convert a Unicode string to an ASCII string 
    std::string strTo; 
    char *szTo = new char[wstr.length() + 1]; 
    szTo[wstr.size()] = '\0'; 
    WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, szTo, (int)wstr.length(), NULL, NULL); 
    strTo = szTo; 
    delete[] szTo; 
    return strTo; 
} 

std::wstring strtowstr(const std::string &str) 
{ 
    // Convert an ASCII string to a Unicode String 
    std::wstring wstrTo; 
    wchar_t *wszTo = new wchar_t[str.length() + 1]; 
    wszTo[str.size()] = L'\0'; 
    MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, wszTo, (int)str.length()); 
    wstrTo = wszTo; 
    delete[] wszTo; 
    return wstrTo; 
} 

-

en cualquier momento en la documentación cuando se ve que tiene un parámetro que es un puntero a un tipo, y ellos dirán que es una variable de salida, tendrá que crear ese tipo, y luego pasa un puntero a él. La función usará ese puntero para llenar su variable.

para que pueda entender esto mejor:

//pX is an out parameter, it fills your variable with 10. 
void fillXWith10(int *pX) 
{ 
    *pX = 10; 
} 

int main(int argc, char ** argv) 
{ 
    int X; 
    fillXWith10(&X); 
    return 0; 
} 

Answer 2

Abundando en la answer proporcionado por Brian R. Bondy: He aquí un ejemplo que muestra por qué no puede simplemente el tamaño del búfer de salida para el número de caracteres anchos en la cadena de origen:

#include <windows.h> 
#include <stdio.h> 
#include <wchar.h> 
#include <string.h> 

/* string consisting of several Asian characters */ 
wchar_t wcsString[] = L"\u9580\u961c\u9640\u963f\u963b\u9644"; 

int main() 
{ 

    size_t wcsChars = wcslen(wcsString); 

    size_t sizeRequired = WideCharToMultiByte(950, 0, wcsString, -1, 
               NULL, 0, NULL, NULL); 

    printf("Wide chars in wcsString: %u\n", wcsChars); 
    printf("Bytes required for CP950 encoding (excluding NUL terminator): %u\n", 
      sizeRequired-1); 

    sizeRequired = WideCharToMultiByte(CP_UTF8, 0, wcsString, -1, 
             NULL, 0, NULL, NULL); 
    printf("Bytes required for UTF8 encoding (excluding NUL terminator): %u\n", 
      sizeRequired-1); 
} 

Y la salida:

Wide chars in wcsString: 6 
Bytes required for CP950 encoding (excluding NUL terminator): 12 
Bytes required for UTF8 encoding (excluding NUL terminator): 18 

Answer 3

Aquí hay un par de funciones (basadas en el ejemplo de Brian Bondy) que usan WideCharToMultiByte y MultiByteToWideChar para convertir entre std :: wstring y std :: string usando utf8 para no perder ningún dato.

// Convert a wide Unicode string to an UTF8 string 
std::string utf8_encode(const std::wstring &wstr) 
{ 
    if(wstr.empty()) return std::string(); 
    int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL); 
    std::string strTo(size_needed, 0); 
    WideCharToMultiByte     (CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL); 
    return strTo; 
} 

// Convert an UTF8 string to a wide Unicode String 
std::wstring utf8_decode(const std::string &str) 
{ 
    if(str.empty()) return std::wstring(); 
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0); 
    std::wstring wstrTo(size_needed, 0); 
    MultiByteToWideChar     (CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed); 
    return wstrTo; 
}