web-dev-qa-db-fra.com

Produire des chaînes unicode dans l'application console Windows

Bonjour, j'essayais de générer une chaîne de caractères Unicode sur une console avec iostreams et j'ai échoué.

J'ai trouvé ceci: Utilisation de la police unicode dans l'application console c ++ et cet extrait fonctionne.

SetConsoleOutputCP(CP_UTF8);
wchar_t s[] = L"èéøÞǽлљΣæča";
int bufferSize = WideCharToMultiByte(CP_UTF8, 0, s, -1, NULL, 0, NULL, NULL);
char* m = new char[bufferSize]; 
WideCharToMultiByte(CP_UTF8, 0, s, -1, m, bufferSize, NULL, NULL);
wprintf(L"%S", m);

Cependant, je n'ai trouvé aucun moyen de sortir correctement unicode avec iostream. Aucune suggestion?

Cela ne fonctionne pas:

SetConsoleOutputCP(CP_UTF8);
utf8_locale = locale(old_locale,new boost::program_options::detail::utf8_codecvt_facet());
wcout.imbue(utf8_locale);
wcout << L"¡Hola!" << endl;

EDIT Je ne trouvais pas d'autre solution que d'envelopper cet extrait dans un flux . J'espère que quelqu'un a de meilleures idées.

//Unicode output for a Windows console 
ostream &operator-(ostream &stream, const wchar_t *s) 
{ 
    int bufSize = WideCharToMultiByte(CP_UTF8, 0, s, -1, NULL, 0, NULL, NULL);
    char *buf = new char[bufSize];
    WideCharToMultiByte(CP_UTF8, 0, s, -1, buf, bufSize, NULL, NULL);
    wprintf(L"%S", buf);
    delete[] buf; 
    return stream; 
} 

ostream &operator-(ostream &stream, const wstring &s) 
{ 
    stream - s.c_str();
    return stream; 
}
c++unicodeiostreamwindows-console
68
Andrew

J'ai vérifié une solution ici à l'aide de Visual Studio 2010. Via cet article Article MSDN et Article de blog MSDN . L'astuce est un obscur appel à _setmode(..., _O_U16TEXT).

Solution:

#include <iostream>
#include <io.h>
#include <fcntl.h>

int wmain(int argc, wchar_t* argv[])
{
    _setmode(_fileno(stdout), _O_U16TEXT);
    std::wcout << L"Testing unicode -- English -- Ελληνικά -- Español." << std::endl;
}

Capture d'écran:

Unicode in console

81
DuckMaestro

Unicode Hello World en chinois

Voici un Hello World en chinois. En fait, c'est juste "Bonjour". J'ai testé cela sur Windows 10, mais je pense que cela pourrait fonctionner depuis Windows Vista . Avant Windows Vista, ce serait difficile, si vous voulez une solution de programmation, au lieu de configurer la console/le registre, etc. ceci est absolument nécessaire sous Windows 7: Changer la police de la console Windows 7

Je ne veux pas prétendre que c'est la seule solution, mais c'est ce qui a fonctionné pour moi.

Contour

  1. Configuration du projet Unicode
  2. Définissez la page de codes de la console sur Unicode.
  3. Recherchez et utilisez une police prenant en charge les caractères que vous souhaitez afficher.
  4. Utilisez les paramètres régionaux de la langue que vous souhaitez afficher
  5. Utilisez la sortie de caractères larges, à savoir std::wcout

1 configuration du projet

J'utilise Visual Studio 2017 CE. J'ai créé une application de console vide. Les paramètres par défaut sont corrects. Mais si vous rencontrez des problèmes ou si vous utilisez une idée différente, vous pouvez vérifier ceux-ci:

Dans les propriétés de votre projet, recherchez les propriétés de configuration -> Général -> Valeurs par défaut du projet -> Jeu de caractères. Ce doit être "Utiliser le jeu de caractères Unicode" et non "Multi-octets" . Ceci définira les macros de préprocesseur _UNICODE et UNICODE.

int wmain(int argc, wchar_t* argv[])

De plus, je pense que nous devrions utiliser la fonction wmain au lieu de main. Ils fonctionnent tous les deux, mais dans un environnement unicode, wmain peut s'avérer plus pratique.

De plus, mes fichiers source sont encodés en UTF-16-LE, ce qui semble être le fichier par défaut dans Visual Studio 2017.

2. Page de code de la console

C'est assez évident. Nous avons besoin de la page de code unicode dans la console . Si vous voulez vérifier votre page de code par défaut, ouvrez simplement une console et tapez chcp sans arguments . Nous devons le changer en 65001, qui est la page de code UTF-8. . Identificateurs de page de code Windows Il existe une macro de préprocesseur pour cette page de code: CP_UTF8. Je devais définir à la fois la page de code d'entrée et de sortie. Quand j'ai omis l'un ou l'autre, la sortie était incorrecte.

SetConsoleOutputCP(CP_UTF8);
SetConsoleCP(CP_UTF8);

Vous pouvez également vouloir vérifier les valeurs de retour booléennes de ces fonctions.

3. Choisissez une police

Jusqu'à présent, je n'ai pas trouvé de police de console compatible avec tous les caractères. Je devais donc en choisir un ... Si vous souhaitez afficher des caractères partiellement disponibles dans une police et dans une autre, je pense qu'il est impossible de trouver une solution. Seulement peut-être s'il existe une police qui supporte tous les caractères. Mais aussi je n'ai pas cherché à savoir comment installer une police.

Je pense qu'il n'est pas possible d'utiliser deux polices différentes dans la même fenêtre de console en même temps.

Comment trouver une police compatible? Ouvrez votre console, accédez aux propriétés de la fenêtre de la console en cliquant sur l’icône située dans le coin supérieur gauche de la fenêtre. Accédez à l'onglet Polices, choisissez une police et cliquez sur OK. Ensuite, essayez de saisir vos caractères dans la fenêtre de la console. Répétez cette opération jusqu'à ce que vous trouviez une police avec laquelle vous pouvez travailler. Ensuite, notez le nom de la police.

Vous pouvez également modifier la taille de la police dans la fenêtre de propriétés . Si vous avez trouvé une taille qui vous convient, notez les valeurs de taille affichées dans la fenêtre de propriétés dans la section "police sélectionnée". Il montrera la largeur et la hauteur en pixels.

Pour définir réellement la police par programme, vous utilisez:

CONSOLE_FONT_INFOEX fontInfo;
// ... configure fontInfo
SetCurrentConsoleFontEx(hConsole, false, &fontInfo);

Voir mon exemple à la fin de cette réponse pour plus de détails . Ou consultez le manuel: SetCurrentConsoleFont . Cette fonction n'existe que depuis Windows Vista.

4. Définir les paramètres régionaux

Vous devrez définir les paramètres régionaux sur ceux de la langue que vous souhaitez imprimer.

char* a = setlocale(LC_ALL, "chinese");

La valeur de retour est intéressante. Il contiendra une chaîne décrivant exactement quelle langue a été choisie . Essayez simplement: -) J'ai testé avec chinese et german. Plus d'infos: setlocale

5. Utilisez une sortie de caractères larges

Pas grand chose à dire ici . Si vous voulez éditer des caractères larges, utilisez ceci par exemple:

std::wcout << L"你好" << std::endl;

Oh, et n'oubliez pas le préfixe L pour les caractères larges! Et si vous tapez des caractères unicode littéraux comme celui-ci dans le fichier source, le fichier source doit être codé en Unicode. Comme par défaut dans Visual Studio, UTF-16-LE. Ou alors, utilisez notepad ++ et définissez le codage sur UCS-2 LE BOM.

Exemple

Enfin, je mets tout cela ensemble à titre d'exemple:

#include <Windows.h>
#include <iostream>
#include <io.h>
#include <fcntl.h>
#include <locale.h>
#include <wincon.h>

int wmain(int argc, wchar_t* argv[])
{
    SetConsoleTitle(L"My Console Window - 你好");
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);

    char* a = setlocale(LC_ALL, "chinese");
    SetConsoleOutputCP(CP_UTF8);
    SetConsoleCP(CP_UTF8);

    CONSOLE_FONT_INFOEX fontInfo;
    fontInfo.cbSize = sizeof(fontInfo);
    fontInfo.FontFamily = 54;
    fontInfo.FontWeight = 400;
    fontInfo.nFont = 0;
    const wchar_t myFont[] = L"KaiTi";
    fontInfo.dwFontSize = { 18, 41 };
    std::copy(myFont, myFont + (sizeof(myFont) / sizeof(wchar_t)), fontInfo.FaceName);

    SetCurrentConsoleFontEx(hConsole, false, &fontInfo);

    std::wcout << L"Hello World!" << std::endl;
    std::wcout << L"你好!" << std::endl;
    return 0;
}

À votre santé !

4
David

Les paramètres régionaux de wcout doivent être définis différemment de ceux du CRT. Voici comment cela peut être corrigé:

int _tmain(int argc, _TCHAR* argv[])
{
    char* locale = setlocale(LC_ALL, "English"); // Get the CRT's current locale.
    std::locale lollocale(locale);
    setlocale(LC_ALL, locale); // Restore the CRT.
    std::wcout.imbue(lollocale); // Now set the std::wcout to have the locale that we got from the CRT.
    std::wcout << L"¡Hola!";
    std::cin.get();
    return 0;
}

Je viens de le tester, et il affiche la chaîne ici parfaitement.

3
Puppy

SetConsoleCP () et chcp ne fait pas la même chose!

Prenez cet extrait de programme:

SetConsoleCP(65001)  // 65001 = UTF-8
static const char s[]="tränenüberströmt™\n";
DWORD slen=lstrlen(s);
WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE),s,slen,&slen,NULL);

Le code source doit être enregistré au format UTF-8. sans pour autant BOM (Byte Order Mark; Signature). Ensuite, le compilateur Microsoft cl.exe prend les chaînes UTF-8 telles quelles.
Si ce code est enregistré avec BOM, cl.exe convertit la chaîne en ANSI (c'est-à-dire CP1252), ce qui ne correspond pas à CP65001 (= UTF-8) .

Changer la police d'affichage en Console Lucidiasinon, la sortie UTF-8 ne fonctionnera pas du tout.

  • Type: chcp
  • Réponse: 850
  • Tapez: test.exe
  • Réponse: tr├ñnen├╝berstr├ÂmtÔäó
  • Type: chcp
  • Réponse: 65001 - Ce paramètre a été modifié par SetConsoleCP() mais sans effet utile.
  • Tapez: chcp 65001
  • Tapez: test.exe
  • Réponse: tränenüberströmt™ - Tout va bien maintenant.

Testé avec: Windows allemand XP SP3

2
Henrik Haftmann

Récemment, je voulais diffuser unicode de Python vers la console Windows et voici le minimum que je devais faire:

  • Vous devez définir la police de la console sur celle qui couvre les symboles Unicode. Il n'y a pas un large choix: Propriétés de la console> Police> Console Lucida
  • Vous devez modifier la page de code de la console actuelle: exécutez chcp 65001 dans la console ou utilisez la méthode correspondante dans le code C++.
  • écrire sur la console avec WriteConsoleW 

Parcourez un article intéressant sur Unicode Java sur la console Windows

De plus, en Python, vous ne pouvez pas écrire dans sys.stdout par défaut. Dans ce cas, vous devrez le remplacer par quelque chose en utilisant os.write (1, binarystring) ou un appel direct à un wrapper autour de WriteConsoleW. On dirait qu'en C++, vous devrez faire de même.

0
newtover

Il existe quelques problèmes avec les flux mswcrt et io.

  1. Trick _setmode (_fileno (stdout), _O_U16TEXT); ne fonctionne que pour MS VC++ et non pas MinGW-GCC. De plus, il est parfois amené à des plantages en fonction de la configuration de Windows.
  2. SetConsoleCP (65001) pour UTF-8. Peut échouer dans de nombreux scénarios de caractères multi-octets, mais est toujours correct pour UTF-16LE
  3. Vous devez restaurer la page de code de la console de prévisualisation à la fermeture de l'application.

La console Windows prend en charge UNICODE avec les fonctions ReadConsole et WriteConsole en mode UTF-16LE. Effet de fond - la tuyauterie dans ce cas ne fonctionnera pas. C'est à dire. myapp.exe >> ret.log amène à 0 octet le fichier ret.log. Si vous êtes d'accord avec ce fait, vous pouvez essayer ma bibliothèque comme suit.

const char* umessage = "Hello!\nПривет!\nПривіт!\nΧαιρετίσματα!\nHelló!\nHallå!\n";

...
#include <console.hpp>
#include <ios>
...

std::ostream& cout = io::console::out_stream();
cout << umessage
<< 1234567890ull << '\n'
<< 123456.78e+09 << '\n'
<< 12356.789e+10L << '\n'
<< std::hex << 0xCAFEBABE
<< std::endl;

Library convertira automatiquement votre UTF-8 en UTF-16LE et l’écrira sur la console à l’aide de WriteConsole. En plus des erreurs et des flux d’entrée ... Un autre avantage de la bibliothèque: les couleurs.

Lien sur l'exemple d'application: https://github.com/incoder1/IO/tree/master/examples/iostreams

La page d'accueil de la bibliothèque: https://github.com/incoder1/IO

Capture d'écran:

0
Victor Gubin

Tout d'abord, désolé, je n'ai probablement pas les polices requises, je ne peux donc pas encore le tester. 

Quelque chose a l'air un peu louche ici

// the following is said to be working
SetConsoleOutputCP(CP_UTF8); // output is in UTF8
wchar_t s[] = L"èéøÞǽлљΣæča";
int bufferSize = WideCharToMultiByte(CP_UTF8, 0, s, -1, NULL, 0, NULL, NULL);
char* m = new char[bufferSize]; 
WideCharToMultiByte(CP_UTF8, 0, s, -1, m, bufferSize, NULL, NULL);
wprintf(L"%S", m); // <-- upper case %S in wprintf() is used for MultiByte/utf-8
                   //     lower case %s in wprintf() is used for WideChar
printf("%s", m); // <-- does this work as well? try it to verify my assumption

tandis que

// the following is said to have problem
SetConsoleOutputCP(CP_UTF8);
utf8_locale = locale(old_locale,
                     new boost::program_options::detail::utf8_codecvt_facet());
wcout.imbue(utf8_locale);
wcout << L"¡Hola!" << endl; // <-- you are passing wide char.
// have you tried passing the multibyte equivalent by converting to utf8 first?
int bufferSize = WideCharToMultiByte(CP_UTF8, 0, s, -1, NULL, 0, NULL, NULL);
char* m = new char[bufferSize]; 
WideCharToMultiByte(CP_UTF8, 0, s, -1, m, bufferSize, NULL, NULL);
cout << m << endl;

qu'en est-il de

// without setting locale to UTF8, you pass WideChars
wcout << L"¡Hola!" << endl;
// set locale to UTF8 and use cout
SetConsoleOutputCP(CP_UTF8);
cout << utf8_encoded_by_converting_using_WideCharToMultiByte << endl;
0
Afriza N. Arief

Encodage par défaut sur: 

  • Windows UTF-16. 
  • Linux UTF-8. 
  • MacOS UTF-8.

Ma solution Steps, inclut les caractères nuls\0 (éviter les caractères tronqués). Sans utiliser les fonctions sur l'en-tête windows.h: 

  1. Ajouter des macros pour détecter la plate-forme.
#if defined (_WIN32) 
#define WINDOWSLIB 1

#Elif defined (__Android__) || defined(Android)//Android
#define ANDROIDLIB 1

#Elif defined (__Apple__)//iOS, Mac OS
#define MACOSLIB 1

#Elif defined (__LINUX__) || defined(__gnu_linux__) || defined(__linux__)//_Ubuntu - Fedora - Centos - RedHat
#define LINUXLIB 1
#endif
  1. Créez des fonctions de conversion std :: w chaîne en std :: string ou vice-versa.
#include <locale>
#include <iostream>
#include <string>
#ifdef WINDOWSLIB
#include <Windows.h>
#endif

using namespace std::literals::string_literals;

// Convert std::wstring to std::string
std::string WidestringToString(const std::wstring& wstr, const std::string& locale)
{
    if (wstr.empty())
    {
        return std::string();
    }
    size_t pos;
    size_t begin = 0;
    std::string ret;
    size_t  size;
#ifdef WINDOWSLIB
    _locale_t lc = _create_locale(LC_ALL, locale.c_str());
    pos = wstr.find(static_cast<wchar_t>(0), begin);
    while (pos != std::wstring::npos && begin < wstr.length())
    {
        std::wstring segment = std::wstring(&wstr[begin], pos - begin);
        _wcstombs_s_l(&size, nullptr, 0, &segment[0], _TRUNCATE, lc);
        std::string converted = std::string(size, 0);
        _wcstombs_s_l(&size, &converted[0], size, &segment[0], _TRUNCATE, lc);
        ret.append(converted);
        begin = pos + 1;
        pos = wstr.find(static_cast<wchar_t>(0), begin);
    }
    if (begin <= wstr.length()) {
        std::wstring segment = std::wstring(&wstr[begin], wstr.length() - begin);
        _wcstombs_s_l(&size, nullptr, 0, &segment[0], _TRUNCATE, lc);
        std::string converted = std::string(size, 0);
        _wcstombs_s_l(&size, &converted[0], size, &segment[0], _TRUNCATE, lc);
        converted.resize(size - 1);
        ret.append(converted);
    }
    _free_locale(lc);
#Elif defined LINUXLIB
    std::string currentLocale = setlocale(LC_ALL, nullptr);
    setlocale(LC_ALL, locale.c_str());
    pos = wstr.find(static_cast<wchar_t>(0), begin);
    while (pos != std::wstring::npos && begin < wstr.length())
    {
        std::wstring segment = std::wstring(&wstr[begin], pos - begin);
        size = wcstombs(nullptr, segment.c_str(), 0);
        std::string converted = std::string(size, 0);
        wcstombs(&converted[0], segment.c_str(), converted.size());
        ret.append(converted);
        ret.append({ 0 });
        begin = pos + 1;
        pos = wstr.find(static_cast<wchar_t>(0), begin);
    }
    if (begin <= wstr.length()) {
        std::wstring segment = std::wstring(&wstr[begin], wstr.length() - begin);
        size = wcstombs(nullptr, segment.c_str(), 0);
        std::string converted = std::string(size, 0);
        wcstombs(&converted[0], segment.c_str(), converted.size());
        ret.append(converted);
    }
    setlocale(LC_ALL, currentLocale.c_str());
#Elif defined MACOSLIB
#endif

    return ret;
}

// Convert std::string to std::wstring
std::wstring StringToWideString(const std::string& str, const std::string& locale)
{
    if (str.empty())
    {
        return std::wstring();
    }

    size_t pos;
    size_t begin = 0;
    std::wstring ret;
    size_t  size;

#ifdef WINDOWSLIB
    _locale_t lc = _create_locale(LC_ALL, locale.c_str());
    pos = str.find(static_cast<char>(0), begin);
    while (pos != std::string::npos) {
        std::string segment = std::string(&str[begin], pos - begin);
        std::wstring converted = std::wstring(segment.size() + 1, 0);
        _mbstowcs_s_l(&size, &converted[0], converted.size(), &segment[0], _TRUNCATE, lc);
        converted.resize(size - 1);
        ret.append(converted);
        ret.append({ 0 });
        begin = pos + 1;
        pos = str.find(static_cast<char>(0), begin);
    }
    if (begin < str.length()) {
        std::string segment = std::string(&str[begin], str.length() - begin);
        std::wstring converted = std::wstring(segment.size() + 1, 0);
        _mbstowcs_s_l(&size, &converted[0], converted.size(), &segment[0], _TRUNCATE, lc);
        converted.resize(size - 1);
        ret.append(converted);
    }
    _free_locale(lc);
#Elif defined LINUXLIB
    std::string currentLocale = setlocale(LC_ALL, nullptr);
    setlocale(LC_ALL, locale.c_str());
    pos = str.find(static_cast<char>(0), begin);
    while (pos != std::string::npos) {
        std::string segment = std::string(&str[begin], pos - begin);
        std::wstring converted = std::wstring(segment.size(), 0);
        size = mbstowcs(&converted[0], &segment[0], converted.size());
        converted.resize(size);
        ret.append(converted);
        ret.append({ 0 });
        begin = pos + 1;
        pos = str.find(static_cast<char>(0), begin);
    }
    if (begin < str.length()) {
        std::string segment = std::string(&str[begin], str.length() - begin);
        std::wstring converted = std::wstring(segment.size(), 0);
        size = mbstowcs(&converted[0], &segment[0], converted.size());
        converted.resize(size);
        ret.append(converted);
    }
    setlocale(LC_ALL, currentLocale.c_str());
#Elif defined MACOSLIB
#endif

    return ret;
}
  1. Affiche std :: string . Vérifiez Suffixe RawString .

Code Linux. Imprimer directement std :: string en utilisant std :: cout.
Si vous avez std :: wstring.
1. Convertir en std :: string.
2. Imprimer avec std :: cout. 

std::wstring x = L"\0\001日本ABC\0DE\0F\0G????\0"s;
std::string result = WidestringToString(x, "en_US.UTF-8");
std::cout << "RESULT=" << result << std::endl;
std::cout << "RESULT_SIZE=" << result.size() << std::endl;

Sous Windows, si vous devez imprimer unicode. Nous devons utiliser WriteConsole pour les caractères d'impression unicode de std :: wstring ou std :: string.

void WriteUnicodeLine(const std::string& s)
{
#ifdef WINDOWSLIB
    WriteUnicode(s);
    std::cout << std::endl;
#Elif defined LINUXLIB
    std::cout << s << std::endl;
#Elif defined MACOSLIB
#endif
}

void WriteUnicode(const std::string& s)
{

#ifdef WINDOWSLIB
    std::wstring unicode = Insane::String::Strings::StringToWideString(s);
    WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), unicode.c_str(), static_cast<DWORD>(unicode.length()), nullptr, nullptr);
#Elif defined LINUXLIB
    std::cout << s;
#Elif defined MACOSLIB
#endif


}

void WriteUnicodeLineW(const std::wstring& ws)
{

#ifdef WINDOWSLIB
    WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), ws.c_str(), static_cast<DWORD>(ws.length()), nullptr, nullptr);
    std::cout << std::endl;
#Elif defined LINUXLIB
    std::cout << String::Strings::WidestringToString(ws)<<std::endl;
#Elif defined MACOSLIB
#endif


}

void WriteUnicodeW(const std::wstring& ws)
{

#ifdef WINDOWSLIB
    WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), ws.c_str(), static_cast<DWORD>(ws.length()), nullptr, nullptr);
#Elif defined LINUXLIB
    std::cout << String::Strings::WidestringToString(ws);
#Elif defined MACOSLIB
#endif

}

Code Windows. Utilisation de la fonction WriteLineUnicode ou WriteUnicode. Le même code peut être utilisé pour Linux. 

std::wstring x = L"\0\001日本ABC\0DE\0F\0G????\0"s;
std::string result = WidestringToString(x, "en_US.UTF-8");
WriteLineUnicode(u8"RESULT" + result);
WriteLineUnicode(u8"RESULT_SIZE" + std::to_string(result.size()));

Enfin sur Windows. Vous avez besoin d’un support puissant et complet pour les caractères unicode dans la console. Je recommande ConEmu et définissez comme terminal par défaut sous Windows . 

Testez sur Microsoft Visual Studio et Jetbrains Clion.

  • Testé sur Microsoft Visual Studio 2017 avec VC++; std = c ++ 17. (Projet Windows)
  • Testé sur Microsoft Visual Studio 2017 avec g ++; std = c ++ 17. (Projet Linux)
  • Testé sur Jetbrains Clion 2018.3 avec g ++; std = c ++ 17. (Chaîne d'outils Linux/à distance)

QA

Q. Pourquoi n'utilisez-vous pas les fonctions et les classes d'en-tête <codecvt> ?.
A. Deprecate Fonctionnalités supprimées ou déconseillées impossible de construire sur VC++, mais pas de problèmes sur g ++. Je préfère 0 avertissements et maux de tête.

Q. wstring sous Windows sont interchangés.
A. Deprecate Fonctionnalités supprimées ou déconseillées impossible de construire sur VC++, mais pas de problèmes sur g ++. Je préfère 0 avertissements et maux de tête. 

Q. std :: wstring est une plateforme croisée?
A. No. std :: wstring utilise des éléments wchar_t. Sous Windows, la taille de wchar_t est de 2 octets. Chaque caractère est stocké dans des unités UTF-16. Si ce caractère est supérieur à U + FFFF, il est représenté dans deux unités UTF-16 (2 éléments wchar_t) appelées paires de substitution. Sous Linux, la taille de wchar_t est de 4 octets. Chaque caractère est stocké dans un élément wchar_t, sans paires de substitution nécessaires. Vérifiez Types de données standard sous UNIX, Linux et Windows .

Q. std :: string est une plateforme croisée?
A. Oui. std :: string utilise des éléments char. le type de caractère garanti est identique à la taille en octets dans tous les compilateurs. la taille du type de caractère est de 1 octet. Vérifiez Types de données standard sous UNIX, Linux et Windows .

0
Joma

Je ne pense pas qu'il y ait une réponse facile. En regardant Pages de code de console et Fonction SetConsoleCP il semble que vous deviez configurer une page de code appropriée pour le jeu de caractères que vous allez afficher.

0
call me Steve