Choisir un caractère

La tradition C et C++ est de prendre le concept de caractère en un sens américain, sans considérer (du moins pas de manière portable) les accents et les symboles alphabétiques propres à d'autres langues que l'anglais.

Le langage Java, un langage commercialisé dans les années '90, et les langages .NET (enfants du XXI^e siècle), ont intégré plus directement les considérations d'internationalisation et l'importance incontournable d'Internet en offrant un support indigène au (très complexe) standard Unicode.

Voir cet article pour des exemples de conversion d'un format à un autre.

De plus en plus, le code C++ doit aussi se mettre à la page. Bien que la tradition (et la plupart des manuels) utilisent les types char, char* et std::string pour représenter des caractères ou des chaînes de caractères, il se trouve que C++ (tout comme C d'ailleurs) supporte depuis longtemps les caractères étendus à l'aide du type primitif wchar_t.

Étant donné que de plus en plus de bibliothèques ont recours à des caractères étendus et que plusieurs de mes étudiant(e)s en sont à leur premier contact avec les notations de caractères étendus en C++, j'ai décidé de mettre sur cette petite page un résumé des choses qui me semble les plus essentielles à connaître pour... disons pour passer au monde moderne.

Caractères traditionnels	Caractères étendus	Remarque
`char c = 'A';`	`wchar_t c = L'A';`	Il suffit de préfixer un littéral char par L pour en faire un littéral wchar_t.
`const char *p = "Allo";`	`const wchar_t *p = L"Allo";`	Il suffit de préfixer un littéral char* par L pour en faire un littéral wchar_t*.
`#include <string> #include <iostream> #include <fstream> #include <sstream>`	`#include <string> #include <iostream> #include <fstream> #include <sstream>`	Rien à changer.
`std::string s = "Allo";`	`std::wstring s = L"Allo";`	Le type std::string et le type std::wstring sont identiques à ceci près que std::string utilise des char comme représentation interne et que std::wstring utilise plutôt des wchar_t.
`std::string s = "Allo"; std::cout << s << 3 << std::endl;`	`std::wstring s = L"Allo"; std::wcout << s << 3 << std::endl;`	Les objets std::cout et std::wcout sont identiques au type de caractère sous-jacent près.
`std::string s; std::cin >> s; std::getline (std::cin, s);`	`std::wstring s; std::wcin >> s; std::getline (std::wcin, s);`	Les objets std::cin et std::wcin sont identiques au type de caractère sous-jacent près. La fonction std::getline() a le même comportement peu importe le type de flux en entrée (vive la programmation générique!)
`std::string s = "L'heure est grave!"; std::cerr << s << std::endl; std::clog << s << std::endl;`	`std::wstring s = L"L'heure est grave!"; std::wcerr << s << std::endl; std::wclog << s << std::endl;`	Il en va de std::cerr/ std::wcerr et de std::clog/ std::wclog comme il en va de std::cin/ std::wcin et de std::cout/ std::wcout.