C++ et l'internationalisation

Avec l'ubiquité du réseau Internet, le village global est véritablement devenu, pour les techno riches du moins, une réalité.

La plupart des outils de programmation récents, en particulier Java et C#, tiennent compte à même leur design de plusieurs considérations propres à l'internationalisation du code, en particulier dans leur gestion des chaînes de caractère, ayant tous deux adopté le standard Unicode comme système d'encodage par défaut du texte. Cela dit, la situation est plus complexe qu'il n'y paraît (voir cette présentation de 2014 par James McNellis pour des détails : https://www.youtube.com/watch?v=n0GK-9f4dl8)

De son côté, C++ reste à bien des égards un dérivé de C, et son support le plus naturel reste, aux yeux de la majorité, offert au texte encodé sur huit bits ou moins comme le sont les standards ASCII et ANSI^[1]. Ce problème en est principalement un de perception, il faut le dire, puisqu'il existe, avec la bibliothèque standard de C++, pratiquement le même support pour les séquences de caractères 8 et 16 bits :

• Les algorithmes standards (std::copy(), std::for_each(), std::generate(), etc.), opèrent tous sur des séquences quelconques;
• Les entrées/ sorties à la console sont supportées aussi naturellement sur des wchar_t (std::wcin, std::wcout, std::wcerr, std::wclog) que sur des char (std::cin, std::cout, std::cerr, std::clog), et
• Il existe des classes de support fonctionnellement identiques pour les chaînes de caractères applicables à des char (std::string) et celles applicables à des wchar_t (std::wstring)

En fait, le plus grand obstacle à l'internationalisation du code C++ est l'habitude que la plupart des gens ont d'utiliser des char (et les opérations et objets qui leur sont apparentés) plutôt que des wchar_t. Une impulsion historique plus que technique, il faut bien le dire.

Cette impulsion qui nous maintient dans nos habitudes d'écrire du code simple mais qui ne fonctionne que dans un environnement « américanocentré » nous fait négliger un aspect très puissant de la bibliothèque standard de C++ qui est son support très complet de l'internationalisation, allant bien au-delà de considérations alphabétiques.

Cette annexe se veut une introduction à l'internationalisation du code en C++, incluant le puissant concept client/ serveur (CS) de facettes, et donne une démonstration non seulement de l'applicabilité du modèle standard, mais aussi de la facilité par laquelle il est possible d'étendre les facettes existantes du modèle d'internationalisation standard.

Représenter les règles locales d'encodage

La première chose à relever quand on adresse la question de l'internationalisation est qu'il s'agit, fondamentalement, d'un problème ouvert. Ce qui constitue la liste de considérations propres à un endroit donné dépend de la culture et des préoccupations propres à ce lieu.

Certains aspects sont reconnus comme plus globaux que d'autres: représentation de la monnaie, des nombres, des dates, etc. D'autres sont moins répandus mais peuvent devoir être pris en considération dans certaines applications ou certains pays. Pensez par exemple :

• À la manière d'identifier la taille des souliers, qui diffère en Europe et en Amérique du Nord
• Aux systèmes de mesure (métrique, impériale, autre)
• Aux structures de pouvoir (république, fédération, royaume, etc.), et ainsi de suite

Dans un souci d'uniformité conceptuelle, la bibliothèque standard de C++ a été réfléchie de manière à supporter, de façon homogène, les facettes jugées d'utilité globale et les facettes qu'on qualifierait de plus spécifiques.

On peut construire une instance de std::locale pour un lieu spécifique en passant une chaîne descriptive dudit lieu en paramètre à son constructeur^[2]. Le constructeur par défaut d'un std::locale crée, sans surprise, une représentation jugée correcte pour la plateforme – avec Visual Studio, comme sur la majorité des plateformes, la présomption est que nous sommes américains, ce qui est associé à la culture dite « classique ».

Culture locale, culture classique

La culture locale peut être obtenue par un appel à std::locale{""} où les guillemets constituent une demande explicite pour un descriptif de la culture locale, telle que définie par la système d'exploitation pour l'environnement d'exécution (donc la culture canadienne française dans votre cas, selon toute probabilité).

La culture classique peut être obtenue par un appel à std::locale() où l'absence de paramètres constitue une demande explicite pour un descriptif de la culture classique, soit celle du langage C et des américains. Appeler std::locale{"C"} est équivalent, et le support pour le nom de culture "C" est garanti par le standard de C++.

Il est possible de choisir un nom de culture spécifique dans un programme en suppléant son nom lors de l'invocation de std::locale() (le paramètre requis étant une chaîne ASCIIZ au sens classique du langage C, donc un pointeur sur une séquence délimitée à la fin par un élément de valeur 0). Les noms de culture supportés ne sont pas standardisés à $100\%$ sur toutes les plateformes, cela dit, et ce problème ne peut être adressé par un langage de programmation. Règle générale, cet irritant ne pose pas vraiment de gros problèmes du fait que la culture de l'usager tend à être celle à laquelle les programmes auront recours.

Imprégner un flux d'une culture

Les entrées/ sorties sont guidées par la culture dont elles sont impégnées. On peut imposer à un programme de respecter les règles propres à une culture donnée. Par exemple, pour appliquer les règles de formatage propres à l'Allemagne dans une sortie à la console sous Microsoft Windows :

std::locale loc{"German_Germany"};
std::cout.imbue(loc); // jusqu'à ce qu'on impose une autre culture, les règles
                      // locales à l'Allemagne seront appliquées

La méthode imbue() d'un flux en sortie imprègne, le mot le dit, ce flux d'un lieu. Elle retourne le lieu dont était précédemment imprégné le flux, ce qui permet facilement d'imposer des règles précises pour quelques opérations d'entrée/ sortie puis de revenir au lieu précédent :

#include <locale>
#include <iostream>

int main() {
   using namespace std;
   //
   // vive le Québec... (les accents ne seront malgré tout pas jolis)
   //
   cout.imbue(locale{"fr_CA"}); // valide avec Windows XP, mais fr_CA est aussi commun
   cout << 3.14159 << endl // la virgule sert de séparateur pour les décimales
        << "Été chaud" << endl << endl;
   //
   // culture locale (devrait être équivalent au cas précédent si vous êtes québecois(e)
   //
   cout.imbue(locale{""});
   cout << 3.14159 << endl // chez moi, la virgule sert de séparateur pour les décimales... et chez vous?
        << "Été chaud" << endl << endl;
   //
   // culture « classique », américaine
   //
   cout.imbue(locale{});
   cout << 3.14159 << endl // le point sert de séparateur pour les décimales
        << "Été chaud" << endl << endl;
   //
   // culture classique, américaine, demandée autrement
   //
   cout.imbue(std::locale("C"));
   cout << 3.14159 << endl // le point sert de séparateur pour les décimales
        << "Été chaud" << endl << endl;
}

Trier des chaînes de caractères

Si vous avez déjà trié des caractères ou des chaînes de caractères, vous avez sans doute remarqué une chose qui peut paraître étrange : par défaut, C++ considère que la valeur de 'a' est plus grande que celle de 'Z', du fait que les valeurs entières associées aux caractères sont utilisées pour les fins de la comparaison, et du fait que dans le format UTF-8 comme dans le format ASCII, le symbole 'A' vaut 65 et le symbole 'a' vaut 97. Si vous voulez voir par vous-mêmes la correspondance entre valeurs entières (Code Points) et symboles affichés, un petit programme comme celui-ci vous permettra de le voir par vous-même :

#include <iostream>
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
   for (int i = 0; i < 128; ++i)
      cout << setw(3) << i << " : '" << static_cast<char>(i) << '\'' << (i % 8 == 7? '\n' : '\t');
}

Portez attention à certains caractères particuliers, soit ceux de valeur 7, 8, 9, 10 et 13 (dans l'ordre : le bell, ou '\a', qui fait un « bip »; le backspace, ou '\b'; la tabulation, ou '\t'; le saut de ligne, ou '\n'; et le retour de chariot, ou '\r'), qui ont un impact sur la présentation à l.'écran.

Cela signifie qu'un programme comme celui-ci :

#include <iostream>
#include <string>
#include <locale>
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
   string txt[] = { "a", "b", "c", "A", "B", "C" };
   sort(begin(txt), end(txt));
   for (const auto & s : txt)
      cout << s << ' ';
   cout << endl;
}

... affichera ce qui suit :

A B C a b c

... ce qui rejoint l'ordre lexicographique, mais ne correspond sans doute pas à votre vision de l'ordre alphabétique.

Le problème de fond est que la gestion de l'ordre dans lequel les symboles doivent être classés pour un alphabet donné dépend de la culture, et qu'il s'agit d'un sujet très, très complexe. Pour que le tri se fasse dans le respect de la culture locale sur le poste exécutant le programme, il faut donc procéder comme suit :

#include <iostream>
#include <string>
#include <locale>
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
   string txt[] = { "a", "b", "c", "A", "B", "C" };
   locale loc{ "" };
   sort(begin(txt), end(txt), loc);
   for (const auto & s : txt)
      cout << s << ' ';
   cout << endl;
}

... ce qui affichera alors :

a A b B c C

Les facettes

Le formatage des nombres est une facette particulière des règles d'internationalisation possibles, mais ce n'est évidemment pas la seule.

• Toute facette est une instance d'une classe dérivée de la classe std::locale::facet, donc d'une classe interne à la classe std::locale.
• Chaque facette représente une particularité culturelle possible (exemples classiques: la représentation d'une date, de la monnaie ou des pointures de chaussures).
• Chaque instance de std::locale peut être vue comme un serveur de facettes, donc comme un objet ayant entre autre pour rôle de fournir des facettes sur demande.

Une facette possible pourrait être la suivante, nommée FacettePolitique, dont le rôle serait de représenter les divers aspects du régime politique dans un lieu donné. Il s'agit d'une classe manifestement trop simple pour représenter cet aspect crucial de la vie humaine qu'est la vie politique, mais il ne s'agit que d'une illustration (je me suis un peu amusé, voilà).

La déclaration de cette classe suit, avec annotation à gauche au besoin.

#ifndef FACETTE_POLITIQUE_H
#define FACETTE_POLITIQUE_H
#include "Incopiable.h"
#include <locale>
#include <string>
class FacettePolitique : public std::locale::facet, Incopiable {
public:
   using str_type = std::string;

// ...
   enum RepartitionPouvoirs {
      Parlementaire, Presidentiel, SemiPresidentiel,
      Dictatorial, Monarchique, Theocratique,
      Totalitaire, Autoritaire
   };
   enum OrganisationTerritoire {
      Federation, Confederation, EtatUnitaire
   };
   enum Autorite {
      Aucun, Dictateur, PremierMinistre,
      President, Tyran
   };

private:
   const str_type chef_etat_;
   const Autorite autorite_;
   const OrganisationTerritoire org_terr_;
   const RepartitionPouvoirs rep_pouv_;

public:
   static std::locale::id id;

// ...
   FacettePolitique
      (const str_type &chef,
       const RepartitionPouvoirs rep,
       const OrganisationTerritoire org,
       const Autorite autorite)
      : chef_etat_{chef}, rep_pouv_{rep},
        org_terr_{org}, autorite_{autorite}
   {
   }

// ...
   str_type chef_etat() const {
      return chef_etat_;
   }
   RepartitionPouvoirs repartition_pouvoirs() const noexcept
      return rep_pouv_;
   }
   OrganisationTerritoire organisation_territoire() const noexcept {
      return org_terr_;
   }
   Autorite autorite() const noexcept {
      return autorite_;
   }
};

std::locale& obtenir_locale();
#endif

Personnellement, j'aime bien représenter l'application d'une facette sur un cas particulier du monde, par exemple le système politique canadien, par un singleton. Je vous propose une telle implémentation, annotée comme le fut la facette en tant que telle.

#ifndef SYSTEME_CANADIEN_H
#define SYSTEME_CANADIEN_H
#include "FacettePolitique.h"
#include "Incopiable.h"
#include <locale>

class SystemeCanadien : Incopiable {
   std::locale ici_;
   SystemeCanadien()
      : ici_{std::locale{""},
              new FacettePolitique
                 {"Justin Trudeau",
                  FacettePolitique::Parlementaire,
                  FacettePolitique::Federation,
                  FacettePolitique::PremierMinistre}}

   {
   }

public:
   std::locale& obtenir_locale() noexcept {
      return ici_;
   }
   static SystemeCanadien &get() {
      static SystemeCanadien singleton;
      return singleton;
   }
};
#endif

#include "FacettePolitique.h"
#include "SystemeCanadien.h"
#include <locale>
using namespace std;
locale::id FacettePolitique::id;
locale& obtenir_locale()
   { return SystemeCanadien::get().obtenir_locale(); }

Exploiter une facette

Comment se comporterait un programme désireux d'obtenir une facette culturelle d'un lieu donné, par exemple du lieu courant? Un exemple correct serait celui ci-dessous.

#include "FacettePolitique.h"
#include <iostream>
#include <locale>
int main() {
   using namespace std;
   auto &ici = obtenir_locale();
   cout.imbue(ici);
   cout << "Chef d'état local: " << use_facet<FacettePolitique>(ici).chef_etat() << endl;
}

La fonction obtenir_locale() est celle que nous avons définie plus haut. Tel que vu précédemment, on imprègne tout d'abord le flux de sortie visé du lieu dont il doit s'inspirer, à l'aide de sa méthode imbue(). Dans ce cas bien précis, que nous l'ayons imprégné de changera pas grand chose à son comportement.

On voit que pour exploiter une facette d'un lieu, il suffit d'appliquer l'opération std::use_facet à un std::locale donné, ce qui donne accès à une référence à la facette en question et permet d'en appeler les méthodes.

La beauté de std::use_facet est que, étant un template, son bon usage est vérifié de manière statique, à la compilation plutôt qu'à l'exécution, et donne donc du code sécuritaire et aussi rapide que possible à l'exécution.

Exemple plus complexe – classe Date respectant les standards locaux

Présumons que nous désirions écrire le programme ci-dessous et souhaitons que celui-ci fonctionne correctement peu importe les standards locaux d'affichage des dates. La classe Date qui y est utilisée est insérée dans un espace nommé (portant le nom chrono_ext) pour éviter des conflits avec d'autres classes Date, ce nom étant assez commun^[3].

#include "Date.h"
#include <iostream>
#include <locale>
int main() {
   using namespace std;
   cout.imbue(locale{""});
   cout << chrono_ext::Date{1972, chrono_ext::Mois::dec, 27} << endl;
}

Notez que la date utilisée dans l'exemple est purement arbitraire, mais que – dû aux choix de représentation internes à la classe chrono_ext::Date, que nous verrons sous peu – elle doit se situer inclusivement entre minuit le 1^er janvier 1970 et 19:14:07 le 18 janvier 2038.

#include <iosfwd>
#include <ctime>
namespace chrono_ext {
   enum class Mois : short {
      jan, fev,  mar, avr, mai, jun,
      jul, aout, sep, oct, nov, dec
   };
   class Date {
      std::time_t brut_;
   public:
      class Invalide { };
      Date(int annee, const Mois mois, int jour);
      void TempsC(struct std::tm*) const;
   };
   std::ostream &operator<<(std::ostream&, const Date&);
}

La méthode TempsC() a pour rôle d'exposer la date représentée par une instance de chrono_ext::Date dans le format traditionnel du langage C pour faciliter l'interopérabilité entre cette classe et le code existant.

On pourrait imaginer plusieurs autres méthodes pertinentes, comme des opérateurs pour ajouter ou soustraire un jour, un mois, un opérateur pour saisir une date d'un flux et ainsi de suite. Nous limiterons toutefois notre exposé à ceci dans le but de garder le tout simple et de rester axés sur les considérations d'internationalisation.

#include "date.h"
#include <ctime>
#include <ostream>
#include <locale>
using namespace std;
namespace chrono_ext {
   Date::Date(int annee, const Mois mois, int jour) {
      struct std::tm moment = { 0 };
      moment.tm_mday = jour;
      moment.tm_mon = static_cast<int>(mois);
      // respecter la norme C
      moment.tm_year = annee - 1900;
      if ((brut_ = mktime(&moment)) == -1)
         throw Invalide{};
   }

void Date::TempsC(struct std::tm* TempsC) const {
   *TempsC = *gmtime(&brut_);
}

Le gros morceau pour l'internationalisation de la classe chrono_ext::Date est lié à son affichage. C'est pourquoi, on le comprendra, l'opérateur << appliqué à un flux en sortie et à une chrono_ext::Date sera le point le plus subtil de notre classe, et ce bien qu'il s'agisse au fond d'une fonction globale et non pas d'une méthode.

// ...
   ostream & operator<<(ostream &os, const Date &date) {
      ostream::sentry cerbere{os};
      if (!static_cast<bool>(cerbere))
         return os;

// ...
      struct tm tmbuf;
      date.TempsC(&tmbuf);

// ...
      const auto &timeFacet = use_facet<time_put<char>>(os.getloc());

// ...
      if (timeFacet.put(os, os, os.fill(), &tmbuf, 'x').failed())
         os.setstate(os.badbit);
      return os;
   }
}

La méthode put() d'une facette std::time_put prend cinq (5) paramètres, mais est moins complexe qu'il n'y paraît :

• Le premier paramètre est le flux où sera écrite la date
• Le deuxième est inutilisé (placé là pour usages futurs)
• Le troisième indique la sorte de caractère à utiliser pour fins d'espacement lors de l'écriture (ici, on utilise le même caractère que le flux en sortie utiliserait normalement)
• Le quatrième est la date en format C standard, et
• Le cinquième est un code de formatage, qui correspond à ceux de la fonction strftime() du langage C

Ce qu'il faut retenir est que dans ce cas, la facette std::time_put est responsable de décrire de manière standardisée les règles d'écriture d'une date pour un lieu et une culture donnés. Les méthodes de std::time_put importent peu, en fait, si on comprend le principe de la facette, puisque chaque facette est potentiellement unique en forme et en fonction.

Lectures complémentaires

Quelques liens pour enrichir le propos.

• Texte de Marco Alesiani en 2016 sur le support d'Unicode dans le langage C++, code à l'appui : http://www.italiancpp.org/2016/04/20/unicode-localization-and-cpp-support/
• L'état de la situation pour ce qui est du support de divers encodages de chaînes de caractères avec Visual Studio, en date de 2016, le tout expliqué par Jim Springfield : https://blogs.msdn.microsoft.com/vcblog/2016/02/22/new-options-for-managing-character-sets-in-the-microsoft-cc-compiler/
• Textes de Raymond Chen :
  • en 2015, Raymond Chen relate un cas amusant où un client signalait que le premier janvier semblait être une date négative : https://blogs.msdn.microsoft.com/oldnewthing/20151112-00/?p=92121/
  • en 2016, Raymond Chen explique comment obtenir le Code Page par défaut pour un locale donné sous Microsoft Windows : https://blogs.msdn.microsoft.com/oldnewthing/20161007-00/?p=94475
• Texte de Todd Rinaldo à propos de la difficulté d'exprimer correctement, de manière programmatique, un truc en apparence aussi simple que l'accord en nombre : hhttp://search.cpan.org/dist/Locale-Maketext/lib/Locale/Maketext/TPJ13.pod
• Quelques croyances erronnées à propos des adresses (postales) : https://www.mjt.me.uk/posts/falsehoods-programmers-believe-about-addresses/
• Texte amusant de 2016 par Chris Baraniuk et Olivia Howitt, à propos d'individus dont les noms ont cette propriété de briser certains systèmes informatiques : http://www.bbc.com/future/story/20160325-the-names-that-break-computer-systems
  • pour un autre texte sur le même sujet, voir https://www.wired.com/2015/11/null/ écrit en 2015 par Christopher Null, et qui se base (manifestement) sur son vécu personnel

^[1] En fait, le standard ANSI est plutôt un standard d'encodage sur sept bits.

^[2] La liste des noms de lieux supportés sur un ordinateur donné est obtenue par la commande locale -a sur les systèmes conformes à la norme POSIX, et par la base de registres sous Microsoft Windows. On peut obtenir le nom descriptif d'un lieu donné en appelant la méthode name() du std::locale le représentant.

^[3] Je me suis fortement inspiré de http://www.cantrip.org/locale.html pour cet exemple.

^[4] Des problèmes de ce genre surviendront fréquemment dans vos cours de systèmes client/ serveur. C'est une bonne technique mais pas essentiel à notre propos.

^[5] ...applicable à un char, mais elle aurait aussi pu être applicable à un wchar_t par exemple.