Wie verwenden Sie richtig WideCharToMultiByte

Question

ich die Dokumentation auf WideCharToMultiByte gelesen habe, aber ich bin auf diesem Parameter fest:

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

Ich bin nicht ganz sicher, wie man richtig um die Variable zu initialisieren und ihn in Die Funktion

Answer 1

Sie verwenden den Parameter lpMultiByteStr [out], indem Sie ein neues char-Array erstellen. Dann übergeben Sie dieses Char-Array, um es gefüllt zu bekommen. Sie müssen nur die Länge der Zeichenfolge + 1 initialisieren, damit nach der Konvertierung eine nullterminierte Zeichenfolge angezeigt wird.

Hier sind ein paar nützliche Hilfsfunktionen für Sie, sie zeigen die Verwendung aller Parameter.

#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; 
} 

-

Immer in der Dokumentation, wenn Sie sehen, dass es einen Parameter aufweist, der ein Zeiger auf einen Typ ist, und sie sagen, es eine aus Variable ist, werden Sie diese Art zu schaffen, und dann einen Zeiger darauf übergeben. Die Funktion wird diesen Zeiger verwenden, um Ihre Variable zu füllen.

So kann man dies besser verstehen:

//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

auf der von Brian R. Bondy bereitgestellt answer Ausarbeiten: ein Beispiel Hier ist, warum Sie zeigt einfach nicht den Ausgabepuffer auf die Anzahl der breiten Zeichen Größe in der Quelle string:

#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); 
} 

und die Ausgabe:

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

Hier sind ein paar Funktionen (basierend auf Brian Bondys Beispiel), die WideCharToMultiByte und MultiByteToWideChar verwenden, um zwischen std :: wstring und std :: string mit utf8 zu konvertieren, um keine Daten zu verlieren.

// 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; 
}