Comment puis-je cin et cout du texte unicode?

Question

Je demande à un extrait de code qui cin un texte unicode, concatène un autre unicode au premier texte unicode et le cout le résultat.

P.S. Ce code m'aidera à résoudre un autre problème plus important avec Unicode. Mais avant que l'essentiel soit d'accomplir ce que je demande.

AJOUTÉ: BTW Je ne peux pas écrire dans la ligne de commande un symbole Unicode lorsque j'exécute le fichier exécutable. Comment je devrais faire ça?

Answer 1

Voici un exemple qui montre quatre méthodes différentes, dont seule la troisième (C conio) et le quatrième (API Windows native) travail (mais seulement si stdin/stdout ne sont pas redirigés) . Notez que vous avez toujours besoin d'une police qui contient le caractère que vous voulez montrer (Lucida Console supporte au moins le grec et le cyrillique). Notez que tout ici est complètement non portable, il n'y a tout simplement aucun moyen portable d'entrer/sortir des chaînes Unicode sur le terminal.

#ifndef UNICODE 
#define UNICODE 
#endif 

#ifndef _UNICODE 
#define _UNICODE 
#endif 

#define STRICT 
#define NOMINMAX 
#define WIN32_LEAN_AND_MEAN 

#include <iostream> 
#include <string> 
#include <cstdlib> 
#include <cstdio> 

#include <conio.h> 
#include <windows.h> 

void testIostream(); 
void testStdio(); 
void testConio(); 
void testWindows(); 

int wmain() { 
    testIostream(); 
    testStdio(); 
    testConio(); 
    testWindows(); 
    std::system("pause"); 
} 

void testIostream() { 
    std::wstring first, second; 
    std::getline(std::wcin, first); 
    if (!std::wcin.good()) return; 
    std::getline(std::wcin, second); 
    if (!std::wcin.good()) return; 
    std::wcout << first << second << std::endl; 
} 

void testStdio() { 
    wchar_t buffer[0x1000]; 
    if (!_getws_s(buffer)) return; 
    const std::wstring first = buffer; 
    if (!_getws_s(buffer)) return; 
    const std::wstring second = buffer; 
    const std::wstring result = first + second; 
    _putws(result.c_str()); 
} 

void testConio() { 
    wchar_t buffer[0x1000]; 
    std::size_t numRead = 0; 
    if (_cgetws_s(buffer, &numRead)) return; 
    const std::wstring first(buffer, numRead); 
    if (_cgetws_s(buffer, &numRead)) return; 
    const std::wstring second(buffer, numRead); 
    const std::wstring result = first + second + L'\n'; 
    _cputws(result.c_str()); 
} 

void testWindows() { 
    const HANDLE stdIn = GetStdHandle(STD_INPUT_HANDLE); 
    WCHAR buffer[0x1000]; 
    DWORD numRead = 0; 
    if (!ReadConsoleW(stdIn, buffer, sizeof buffer, &numRead, NULL)) return; 
    const std::wstring first(buffer, numRead - 2); 
    if (!ReadConsoleW(stdIn, buffer, sizeof buffer, &numRead, NULL)) return; 
    const std::wstring second(buffer, numRead); 
    const std::wstring result = first + second; 
    const HANDLE stdOut = GetStdHandle(STD_OUTPUT_HANDLE); 
    DWORD numWritten = 0; 
    WriteConsoleW(stdOut, result.c_str(), result.size(), &numWritten, NULL); 
} 

• Edit 1: J'ai ajouté une méthode basée sur conio.
• Edit 2: J'ai foiré autour avec _O_U16TEXT un peu comme décrit dans le blog de Michael Kaplan, mais apparemment seulement eu wgets interpréter les données (8 bits) de ReadFile en UTF-16. Je vais enquêter un peu plus loin pendant le week-end.

Answer 2

Cela dépend du système d'exploitation. Si votre OS comprend, vous pouvez simplement lui envoyer des séquences UTF-8. Selon le type d'Unicode que vous entendez,

Answer 3

Je suppose que vous voulez dire que vous travaillez avec std::wstring cependant. Dans ce cas, utilisez std::wcin et std::wcout.

Pour la conversion entre encodages vous pouvez utiliser les fonctions de votre OS comme pour Win32: WideCharToMultiByte, MultiByteToWideChar ou vous pouvez utiliser une bibliothèque comme libiconv

Answer 4

Si vous avez un texte réel (par exemple une chaîne de caractères logiques), puis insérez aux larges cours d'eau à la place. Les flux larges encoderont automatiquement vos caractères pour qu'ils correspondent aux bits attendus par le codage des paramètres régionaux. (Et si vous avez des bits codés à la place, les flux vont décoder les bits, puis les réencoder pour les faire correspondre aux paramètres régionaux.)

Il existe une solution moindre si vous SAVEZ que vous avez des bits codés en UTF (c'est-à-dire un tableau des bits destinés à être décodés en une chaîne de caractères logiques) ET vous CONNAISSEZ que la cible du flux de sortie attend ce même format de bits, alors vous pouvez ignorer les étapes de décodage et de recodage et écrire() les bits comme si. Cela fonctionne uniquement lorsque vous savez que les deux côtés utilisent le même format de codage, ce qui peut être le cas pour les petits utilitaires qui ne sont pas destinés à communiquer avec des processus dans d'autres paramètres régionaux.

Answer 5

J'ai eu un problème similaire dans le passé, dans mon cas imbue et sync_with_stdio fait l'affaire. Essayez ceci:

#include <iostream> 
#include <locale> 
#include <string> 

using namespace std; 

int main() { 
    ios_base::sync_with_stdio(false); 
    wcin.imbue(locale("en_US.UTF-8")); 
    wcout.imbue(locale("en_US.UTF-8")); 

    wstring s; 
    wstring t(L" la Polynésie française"); 

    wcin >> s; 
    wcout << s << t << endl; 
    return 0; 
}