16.2. Les facettes standards

16.2.2.1. La facette ctype

La facette ctype dérive d'une classe de base dans laquelle sont définies les différentes catégories de caractères. Cette classe est déclarée comme suit dans l'en-tête locale :

class ctype_base
{
public:
    enum mask
    {
        space = SPACE_VALUE, print = PRINT_VALUE,
        cntrl = CNTRL_VALUE, alpha = ALPHA_VALUE,
        digit = DIGIT_VALUE, xdigit = XDIGIT_VALUE,
        upper = UPPER_VALUE, lower = LOWER_VALUE,
        punct = PUNCT_VALUE,
        alnum = alpha | digit, graph = alnum | punct
    };
};

La classe template ctype quant à elle est déclarée comme suit dans l'en-tête locale :

template <class charT>
class ctype : public locale::facet, public ctype_base
{
public:
// Les types de données :
    typedef charT char_type;

// Le constructeur :
    explicit ctype(size_t refs = 0);

// Les méthode de classification :
    bool        is(mask m, charT c) const;
    const charT *is(const charT *premier, const charT *dernier,
        mask *vecteur) const;
    const charT *scan_is(mask m,
        const charT *premier, const charT *dernier) const;
    const charT *scan_not(mask m,
        const charT *premier, const charT *dernier) const;
    charT        toupper(charT c) const;
    const charT *toupper(const charT *premier, const charT *dernier) const;
    charT        tolower(charT c) const;
    const charT *tolower(const charT *premier, const charT *dernier) const;
    charT        widen(char c) const;
    const charT *widen(const char *premier, const char *dernier,
        charT *destination) const;
    char         narrow(charT c, char defaut) const;
    const char  *narrow(const charT *premier, const charT *dernier,
        char defaut, char *destination) const;

// L'identificateur de la facette :
    static locale::id id;
};

Les méthodes scan_is et scan_not permettent de rechercher un caractère selon un critère particulier dans un tableau de caractères. La méthode scan_is recherche le premier caractère qui est du type indiqué par son paramètre m, et la méthode scan_not le premier caractère qui n'est pas de ce type. Ces deux méthodes prennent en paramètre un pointeur sur le premier caractère du tableau dans lequel la recherche doit s'effectuer et le pointeur suivant l'emplacement du dernier caractère de ce tableau. Elles renvoient toutes les deux un pointeur référençant le caractère trouvé, ou le pointeur de fin si aucun caractère ne vérifie le critère spécifié.

Les autres méthodes de la facette ctype sont fournies sous deux versions. La première permet d'effectuer une opération sur un caractère unique et la deuxième permet de reproduire cette opération sur une séquence de caractères consécutifs. Dans ce dernier cas, les caractères sur lesquels l'opération peut être effectuée sont spécifiés à l'aide de deux pointeurs, l'un sur le premier caractère et l'autre sur le caractère suivant le dernier caractère de la séquence, comme il est d'usage de le faire dans tous les algorithmes de la bibliothèque standard.

Les deux méthodes is permettent donc respectivement de déterminer si un caractère est du type indiqué par le paramètre m ou non, ou d'obtenir la suite des descriptions de chaque caractère dans le tableau de valeur de type mask pointé par le paramètre vecteur. De même, les méthodes toupper et tolower permettent respectivement de convertir un caractère unique ou tous les caractères d'un tableau en majuscule ou en minuscule. La méthode widen permet de transtyper un caractère ou tous les caractères d'un tableau de type char en caractères du type par lequel la classe ctype est paramétrée. Enfin, les méthodes narrow permettent de réaliser l'opération inverse, ce qui peut provoquer une perte de données puisque le type char est le plus petit des types de caractères qui puisse exister. Il est donc possible que le transtypage ne puisse se faire, dans ce cas, les méthodes narrow utilisent la valeur par défaut spécifiée par le paramètre defaut.

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

using namespace std;

int main(void)
{
    // Fixe la locale globale aux préférences de l'utilisateur :
    locale::global(locale(""));
    // Lit une chaîne de caractères larges :
    wstring S;
    wcin >> S;
    // Récupère la facette ctype<wchar_t> de la locale courante :
    const ctype<wchar_t> &f =
        use_facet<ctype<wchar_t> >(locale());
    // Construit un tampon pour recevoir le résultat de la conversion :
    size_t l = S.length() + 1;
    char *tampon = new char[l];
    // Effectue la conversion :
    f.narrow(S.c_str(), S.c_str() + l, 'E', tampon);
    // Affiche le résultat :
    cout << tampon << endl;
	delete[] tampon;
    return 0;
}

Vous constaterez que l'utilisation de la méthode is pour déterminer la nature des caractères peut être relativement fastidieuse, car il faut récupérer la facette ctype, déterminer la valeur du masque à utiliser, puis appeler la méthode. La bibliothèque standard définit donc un certain nombre de fonctions globales utilitaires dans l'en-tête locale :

template <class charT> bool isspace (charT c, const locale &l) const;
template <class charT> bool isprint (charT c, const locale &l) const;
template <class charT> bool iscntrl (charT c, const locale &l) const;
template <class charT> bool isupper (charT c, const locale &l) const;
template <class charT> bool islower (charT c, const locale &l) const;
template <class charT> bool isalpha (charT c, const locale &l) const;
template <class charT> bool isdigit (charT c, const locale &l) const;
template <class charT> bool ispunct (charT c, const locale &l) const;
template <class charT> bool isxdigit(charT c, const locale &l) const;
template <class charT> bool isalnum (charT c, const locale &l) const;
template <class charT> bool isgraph (charT c, const locale &l) const;
template <class charT> charT toupper(charT c, const locale &l) const;
template <class charT> charT tolower(charT c, const locale &l) const;

L'utilisation de ces fonctions ne doit pas poser de problème particulier. Elles prennent toutes en premier paramètre le caractère à caractériser et en deuxième paramètre la locale dont la facette ctype doit être utilisée pour réaliser cette caractérisation. Chaque fonction permet de tester le caractère pour l'appartenance à l'une des catégories de caractères définies dans la classe de base ctype_base. Notez cependant que si un grand nombre de caractères doivent être caractérisés pour une même locale, il est plus performant d'obtenir la facette ctype de cette locale une bonne fois pour toutes et d'effectuer les appels à la méthode is en conséquence.

La classe ctype étant une classe template, elle peut être utilisée pour n'importe quel type de caractère a priori. Toutefois, il est évident que cette classe peut être optimisée pour les types de caractère simples, et tout particulièrement pour le type char, parce qu'il ne peut pas prendre plus de 256 valeurs différentes. La bibliothèque standard définit donc une spécialisation totale de la classe template ctype pour le type char. L'implémentation de cette spécialisation se base sur un tableau de valeurs de type mask indexée par les valeurs que peuvent prendre les variables de type char. Ce tableau permet donc de déterminer rapidement les caractéristiques de chaque caractère existant. Le constructeur de cette spécialisation diffère légèrement du constructeur de sa classe template car il peut prendre en paramètre un pointeur sur ce tableau de valeurs et un booléen indiquant si ce tableau doit être détruit automatiquement par la facette lorsqu'elle est elle-même détruite ou non. Ce constructeur prend également en troisième paramètre une valeur de type entier indiquant, comme pour toutes les facettes standards, si la locale doit prendre en charge la gestion de la durée de vie de la facette ou non. Les autres méthodes de cette spécialisation sont identiques aux méthodes de la classe template de base et ne seront donc pas décrites ici.

16.2.2.2. La facette codecvt

La facette codecvt permet de réaliser les opérations de conversion d'un mode de représentation des caractères à un autre. En général, en informatique, les caractères sont codés par des nombres. Le type de ces nombres, ainsi que la manière de les utiliser, peut varier grandement d'une représentation à une autre, et les conversions peuvent ne pas se faire simplement. Par exemple, certaines représentations codent chaque caractère avec une valeur unique du type de caractère utilisé, mais d'autres codent les caractères sur des séquences de longueur variable. On ne peut dans ce cas bien entendu pas convertir directement une représentation en une autre, car l'interprétation que l'on peut faire des nombres représentant les caractères dépend du contexte déterminé par les nombres déjà lus. Les opérations de conversion ne sont donc pas toujours directes.

De plus, dans certains encodages à taille variable, l'interprétation des caractères peut dépendre des caractères déjà convertis. La facette codecvt maintient donc un état pendant les conversions qu'elle effectue, état qui lui permet de reprendre la conversion d'une séquence de caractères dans le cas de conversions réalisées en plusieurs passes. Bien entendu, tous les encodages ne nécessitent pas forcément le maintien d'un tel état. Cependant, certains l'exigent et il faut donc toujours le prendre en compte dans les opérations de conversion si l'on souhaite que le programme soit portable. Pour les séquences de caractères à encodage variable utilisant le type de caractère de base char, le type de la variable d'état permettant de stocker l'état courant du convertisseur est le type mbstate_t. D'autres types peuvent être utilisés pour les séquences basées sur des types de caractères différents du type char, mais en général, tous les encodages à taille variable se basent sur ce type. Quoi qu'il en soit, la classe codecvt définit un type de donnée capable de stocker l'état d'une conversion partielle. Ce type est le type state_type, qui pourra donc toujours être récupéré dans la classe codecvt. La variable d'état du convertisseur devra être systématiquement fournie aux méthodes de conversion de la facette codecvt et devra bien entendu être initialisée à sa valeur par défaut au début de chaque nouvelle conversion.

La facette codecvt dérive d'une classe de base nommée codecvt_base. Cette classe définit les différents résultats que peuvent avoir les opérations de conversion. Elle est déclarée comme suit dans l'en-tête locale :

class codecvt_base
{
public:
    enum result
    {
        ok, partial, error, noconv
    };
};

Comme vous pouvez le constater, une conversion peut se réaliser complètement (code de résultat ok), partiellement par manque de place dans la séquence destination ou par manque de données en entrées (code partial), ou pas du tout, soit en raison d'une erreur de conversion (code d'erreur error), soit parce qu'aucune conversion n'est nécessaire (code de résultat noconv).

La classe template codecvt elle-même est définie comme suit dans l'en-tête locale :

template <class internT, class externT, class stateT>
class codecvt : public locale::facet, public codecvt_base
{
public:
// Les types de données :
    typedef internT intern_type;
    typedef externT extern_type;
    typedef stateT  state_type;

// Le constructeur :
    explicit codecvt(size_t refs=0);

// Les fonctions de conversion :
    result out(stateT &etat, const internT *premier,
        const internT *dernier, const internT *&suiv_source,
        externT *dernier, externT *limite, externT *&suiv_dest) const;
    result in(stateT &etat, const externT *premier,
        const externT *dernier, const externT *&suiv_source,
        internT *dernier, internT *limite, internT *&suiv_dest) const;
    result unshift(stateT &etat,
        externT *dernier, externT *limite, externT *&suiv_dest) const;
    int length(const stateT &etat,
        const externT *premier, const externT *dernier, size_t max) const;
    int max_length() const throw();
    int encoding() const throw();
    bool always_noconv() const throw();

// L'identificateur de la facette :
    static locale::id id;
};

Cette classe template est paramétrée par le type de caractère interne à la classe codecvt, par un deuxième type de caractère qui sera par la suite dénommé type externe, et par le type des variables destinées à recevoir l'état courant d'une conversion. Les implémentations de la bibliothèque standard doivent obligatoirement instancier cette classe template pour les types char et wchar_t. Le type de gestion de l'état des conversions utilisé est alors le type prédéfini mbstate_t, qui permet de conserver l'état des conversions entre le type natif wchar_t et les séquences de caractères simples à taille variable. Ainsi, vous pourrez toujours utiliser les instances codecvt<wchar_t, char, mbstate_t> et codecvt<char, char, mbstate_t> de la facette codecvt dans vos programmes. Si vous désirez réaliser des conversions pour d'autres types de caractères, vous devrez fournir vous-même des spécialisations de la facette codecvt.

Les méthodes in et out permettent respectivement, comme leurs signatures l'indiquent, de réaliser les conversions entre les types interne et externe et vice versa. Elles prennent toutes deux sept paramètres. Le premier paramètre est une référence sur la variable d'état qui devra être fournie à chaque appel lors de conversions successives d'un même flux de données. Cette variable est destinée à recevoir l'état courant de la conversion et permettra aux appels suivants de convertir correctement les caractères suivants du flux d'entrée. Les deux paramètres suivants permettent de spécifier la séquence de caractères à convertir. Ils doivent contenir le pointeur sur le début de la séquence et le pointeur sur le caractère suivant le dernier caractère de la séquence. Le quatrième paramètre est un paramètre de retour, la fonction lui affectera la valeur du pointeur où la conversion s'est arrêtée. Une conversion peut s'arrêter à cause d'une erreur ou tout simplement parce que le tampon destination ne contient pas assez de place pour accueillir un caractère de plus. Ce pointeur pourra être utilisé dans un appel ultérieur comme pointeur de départ avec la valeur de la variable d'état à l'issue de la conversion pour effectuer la suite de cette conversion. Enfin, les trois derniers paramètres spécifient le tampon destination dans lequel la séquence convertie doit être écrite. Ils permettent d'indiquer le pointeur de début de ce tampon, le pointeur suivant le dernier emplacement utilisable, et un pointeur de retour qui indiquera la dernière position écrite par l'opération de conversion. Ces deux méthodes renvoient une des constantes de l'énumération result définie dans la classe de base codecvt_base pour indiquer comment la conversion s'est effectuée. Si aucune conversion n'est nécessaire, les pointeurs sur les caractères suivants sont initialisés à la valeur des pointeurs de début de séquence et aucune écriture n'a lieu dans le tampon destination.

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

using namespace std;

int main(void)
{
    // Fixe la locale globale :
    locale::global(locale(""));
    // Lit une ligne :
    wstring S;
    getline(wcin, S);
    // Récupère la facette de conversion vers wchar_t :
    const codecvt<wchar_t, char, mbstate_t> &f =
        use_facet<codecvt<wchar_t, char, mbstate_t> >(locale());
    // Effectue la conversion :
    const wchar_t *premier = S.c_str();
    const wchar_t *dernier = premier + S.length();
    const wchar_t *suivant = premier;
    string s;
    char tampon[10];
    char *fincvt = tampon;
    codecvt_base::result r;
    mbstate_t etat = mbstate_t();
    while (premier != dernier)
    {
        // Convertit un morceau de la chaîne :
        r = f.out(etat, premier, dernier, suivant,
            tampon, tampon+10, fincvt);
        // Vérifie les erreurs possibles :
        if (r == codecvt_base::ok || r == codecvt_base::partial)
            cout << "." << flush;
        else if (r == codecvt_base::noconv)
        {
            cout << "conversion non nécessaire" << endl;
            break;
        }
        else if (r == codecvt_base::error)
        {
            cout << "erreur" << endl;
            cout << suivant - premier << endl;
            cout << fincvt - tampon << endl;
            break ;
        }
        // Récupère le résultat et prépare la conversion suivante :
        s.append(tampon, fincvt - tampon);
        premier = suivant;
    }
    cout << endl;
    // Affiche le résultat :
    cout << s << endl;
    return 0;
}

Il est possible de compléter une séquence de caractères à encodage variable de telle sorte que la variable d'état du convertisseur soit réinitialisée. Cela permet de terminer une chaîne de caractères partiellement convertie, ce qui en pratique revient à compléter la séquence de caractères avec les données qui représenteront le caractère nul terminal. Cette opération peut être réalisée à l'aide de la méthode unshift de la facette codecvt. Cette méthode prend en paramètre une référence sur la variable d'état du convertisseur, ainsi que les pointeurs de début et de fin du tampon dans lequel les valeurs à ajouter sont écrites. Le dernier paramètre de la méthode unshift est une référence sur un pointeur qui recevra l'adresse suivant celle la dernière valeur écrite par la méthode si l'opération se déroule correctement.

Il va de soi que la détermination de la longueur d'une chaîne de caractères dont les caractères ont une représentation à taille variable n'est pas simple. La facette codecvt comporte donc une méthode length permettant de calculer, en nombre de caractères de type intern_type, la longueur d'une séquence de caractères de type extern_type. Cette méthode prend en paramètre la variable d'état du convertisseur ainsi que les pointeurs spécifiant la séquence de caractères dont la longueur doit être calculée. Le dernier paramètre est la valeur maximale que la fonction peut retourner. Elle permet de limiter la détermination de la longueur de la séquence source à une borne maximale, par exemple la taille d'un tampon destination. La valeur retournée est bien entendu la longueur de cette séquence ou, autrement dit, le nombre de valeurs de type intern_type nécessaires pour stocker le résultat de la conversion que la méthode in ferait avec les mêmes paramètres. D'autre part, il est possible de déterminer le nombre maximal de valeurs de type intern_type nécessaires pour représenter un unique caractère représenté par une séquence de caractères de type extern_type. Pour cela, il suffit d'appeler la méthode max_length de la facette codecvt.

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

using namespace std;

int main(void)
{
    // Fixe la locale globale :
    locale::global(locale(""));
    // Lit une ligne :
    string s;
    getline(cin, s);
    // Récupère la facette de conversion vers wchar_t :
    const codecvt<wchar_t, char, mbstate_t> &f =
        use_facet<codecvt<wchar_t, char, mbstate_t> >(locale());
    // Affiche la longueur de la chaîne d'entrée :
    int l1 = s.length();
    // Calcule la longueur de la ligne en wchar_t :
    mbstate_t etat = mbstate_t();
    int l2 = f.length(etat, s.c_str(), s.c_str() + l1,
        numeric_limits<size_t>::max());
    // Affiche les deux longueurs :
    cout << l1 << endl;
    cout << l2 << endl;
    return 0;
}

Comme on l'a déjà indiqué ci-dessus, toutes les représentations des caractères ne sont pas à taille variable et toutes les représentations ne nécessitent pas forcément l'utilisation d'une variable d'état de type state_type. Vous pouvez déterminer dynamiquement si le mode de représentation des caractères du type intern_type utilise un encodage à taille variable ou non à l'aide de la méthode encoding. Cette méthode renvoie -1 si la représentation des caractères de type extern_type dépend de l'état du convertisseur, ou le nombre de caractères de type extern_type nécessaires au codage d'un caractère de type intern_type si ce nombre est constant. Si la valeur renvoyée est 0, ce nombre n'est pas constant, mais, contrairement à ce qui se passe lorsque la valeur renvoyée est -1, ce nombre ne dépend pas de la valeur de la variable d'état du convertisseur.

Enfin, certains modes de représentation des caractères sont compatibles, voire franchement identiques. Dans ce cas, jamais aucune conversion n'est réalisée, et les méthodes in et out renvoient toujours noconv. C'est par exemple le cas de la spécialisation codecvt<char, char, mbstate_t> de la facette codecvt. Vous pouvez déterminer si une facette effectuera des conversions ou non en appelant la méthode always_noconv. Elle retourne true si jamais aucune conversion ne se fera et false sinon.

16.2.4.1. La facette num_punct

La facette qui regroupe tous les paramètres de la locale est la facette num_punct. Elle est déclarée comme suit dans l'en-tête locale :

template <class charT>
class numpunct : public locale::facet
{
public:
// Les types de données :
    typedef charT               char_type;
    typedef basic_string<charT> string_type;

// Le constructeur :
    explicit numpunct(size_t refs = 0);

// Les méthodes de lecture des options de formatage des nombres :
    char_type    decimal_point()   const;
    char_type    thousands_sep()   const;
    string       grouping()        const;
    string_type  truename()        const;
    string_type  falsename()       const;

// L'identificateur de la facette :
    static locale::id id;
};

La méthode decimal_point permet d'obtenir le caractère qui doit être utilisé pour séparer le chiffre des unités des chiffres après la virgule lors des opérations de formatage des nombres à virgule. La valeur par défaut est le caractère '.', mais en France, le caractère utilisé est la virgule (caractère ','). De même, la méthode thousands_sep permet de déterminer le caractère qui est utilisé pour séparer les groupes de chiffres lors de l'écriture des grands nombres. La valeur par défaut renvoyée par cette fonction est le caractère virgule (caractère ','), mais dans les locales françaises, on utilise généralement un espace (caractère ' '). Enfin, la méthode grouping permet de déterminer les emplacements où ces séparateurs doivent être introduits. La chaîne de caractères renvoyée détermine le nombre de chiffres de chaque groupe de chiffres. Le nombre de chiffres du premier groupe est ainsi stocké dans le premier caractère de la chaîne de caractères renvoyée par la méthode grouping, celui du deuxième groupe est stocké dans le deuxième caractère, et ainsi de suite. Le dernier nombre ainsi obtenu dans cette chaîne de caractères est ensuite utilisé pour tous les groupes de chiffres suivants, ce qui évite d'avoir à définir une chaîne de caractères arbitrairement longue. Un nombre de chiffres nul indique que le mécanisme de groupage des chiffres des grands nombres est désactivé. Les facettes de la plupart des locales renvoient la valeur "\03", ce qui permet de grouper les chiffres par paquets de trois (milliers, millions, milliards, etc.).

Les méthodes truename et falsename quant à elles permettent aux facettes de formatage d'obtenir les chaînes de caractères qui représentent les valeurs true et false des booléens. Ce sont ces chaînes de caractères qui sont utilisées lorsque l'option de formatage boolalpha a été activée dans les flux d'entrée / sortie. Les valeurs retournées par ces méthodes sont, par défaut, les mots anglais true et false. Il est concevable dans d'autres locales, cependant, d'avoir des noms différents pour ces deux valeurs. Nous verrons dans la Section 16.3.2 la manière de procéder pour redéfinir ces méthodes et construire ainsi une locale personnalisée et francisée.

16.2.4.2. La facette d'écriture des nombres

L'écriture et le formatage des nombres sont pris en charge par la facette num_put. Cette facette est déclarée comme suit dans l'en-tête locale :

template <class charT,
    class OutputIterator = ostreambuf_iterator<charT> >
class num_put : public locale::facet
{
public:
// Les types de données :
    typedef charT          char_type;
    typedef OutputIterator iter_type;

// Le constructeur :
    explicit num_put(size_t refs = 0);

// Les méthodes d'écriture des nombres :
    iter_type put(iter_type s, ios_base &f, char_type remplissage, bool v) const;
    iter_type put(iter_type s, ios_base &f, char_type remplissage, long v) const;
    iter_type put(iter_type s, ios_base &f, char_type remplissage,
        unsigned long v) const;
    iter_type put(iter_type s, ios_base &f, char_type remplissage,
        double v) const;
    iter_type put(iter_type s, ios_base &f, char_type remplissage,
        long double v) const;
    iter_type put(iter_type s, ios_base &f, char_type remplissage,
        void *v) const;

// L'identificateur de la facette :
    static locale::id id;
};

Comme vous pouvez le constater, cette facette dispose d'une surcharge de la méthode put pour chacun des types de base du langage. Ces surcharges prennent en paramètre un itérateur d'écriture sur le flux de sortie sur lequel les données formatées devront être écrites, une référence sur le flux de sortie contenant les options de formatage à utiliser lors du formatage des nombres, le caractère de remplissage à utiliser, et bien entendu la valeur à écrire.

En général, ces méthodes sont appelées au sein des opérateurs d'insertion operator<< pour chaque type de donnée existant. De plus, le flux de sortie sur lequel les écritures doivent être effectuées est le même que le flux servant à spécifier les options de formatage, si bien que l'appel aux méthodes put est extrêmement simplifié. Nous verrons plus en détail la manière d'appeler ces méthodes dans la Section 16.3.1, lorsque nous écrirons une nouvelle facette pour un nouveau type de donnée.

16.2.4.3. La facette de lecture des nombres

Les opérations de lecture des nombres à partir d'un flux de données sont prises en charge par la facette num_get. Cette facette est déclarée comme suit dans l'en-tête locale :

template <class charT,
    class InputIterator = istreambuf_iterator<charT> >
class num_get : public locale::facet
{
public:
// Les types de données :
    typedef charT         char_type;
    typedef InputIterator iter_type;

// Le constructeur :
    explicit num_get(size_t refs = 0);

// Les méthodes de lecture des nombres :
    iter_type get(iter_type in, iter_type end, ios_base &,
        ios_base::iostate &err, bool &v) const;
    iter_type get(iter_type in, iter_type end, ios_base &,
        ios_base::iostate &err, long &v) const;
    iter_type get(iter_type in, iter_type end, ios_base &,
        ios_base::iostate &err, unsigned short &v) const;
    iter_type get(iter_type in, iter_type end, ios_base &,
        ios_base::iostate &err, unsigned int &v) const;
    iter_type get(iter_type in, iter_type end, ios_base &,
        ios_base::iostate &err, unsigned long &v) const;
    iter_type get(iter_type in, iter_type end, ios_base &,
        ios_base::iostate &err, float &v) const;
    iter_type get(iter_type in, iter_type end, ios_base &,
        ios_base::iostate &err, double &v) const;
    iter_type get(iter_type in, iter_type end, ios_base &,
        ios_base::iostate &err, long double &v) const;
    iter_type get(iter_type in, iter_type end, ios_base &,
        ios_base::iostate &err, void *&v) const;

// L'identificateur de la facette :
    static locale::id id;
};

Comme vous pouvez le constater, cette facette ressemble beaucoup à la facette num_put. Il existe en effet une surcharge de la méthode get pour chaque type de base du langage. Ces méthodes sont capables d'effectuer la lecture des données de ces types à partir du flux d'entrée, en tenant compte des paramètres des locales et des options de formatage du flux. Ces méthodes prennent en paramètre un itérateur de flux d'entrée, une valeur limite de cet itérateur au-delà de laquelle la lecture du flux ne se fera pas, la référence sur le flux d'entrée contenant les options de formatage et deux paramètres de retour. Le premier paramètre recevra un code d'erreur de type iostate qui pourra être positionné dans le flux d'entrée pour signaler l'erreur. Le deuxième est une référence sur la variable devant accueillir la valeur lue. Si une erreur se produit, cette variable n'est pas modifiée.

Les méthodes get sont généralement utilisées par les opérateurs d'extraction operator>> des flux d'entrée / sortie pour les types de données de base du langage. En général, ces opérateurs récupèrent la locale incluse dans le flux d'entrée sur lequel ils travaillent et utilisent la facette num_get de cette locale. Ils appellent alors la méthode get permettant de lire la donnée qu'ils doivent extraire, en fournissant ce même flux en paramètre. Ils testent ensuite la variable d'état retournée par la méthode get et, si une erreur s'est produite, modifient l'état du flux d'entrée en conséquence. Cette dernière opération peut bien entendu provoquer le lancement d'une exception, selon le masque d'exceptions utilisé pour le flux.

16.2.5.1. La facette money_punct

La facette moneypunct est la facette permettant aux deux facettes d'écriture et de lecture des montants d'obtenir les informations relatives à la monnaie de leur locale. Cette facette est déclarée comme suit dans l'en-tête locale :

template <class charT, bool International = false>
class moneypunct : public locale::facet, public money_base
{
public:
// Les types de données :
    typedef charT char_type;
    typedef basic_string<charT> string_type;

// Le constructeur :
    explicit moneypunct(size_t refs = 0);

// Les méthodes de lecture des options de formatage des montants :
    charT       decimal_point() const;
    charT       thousands_sep() const;
    string      grouping()      const;
    int         frac_digits()   const;
    string_type curr_symbol()   const;
    pattern     pos_format()    const;
    pattern     neg_format()    const;
    string_type positive_sign() const;
    string_type negative_sign() const;
    static const bool intl = International;

// L'identificateur de la facette :
    static locale::id id;
};

Comme vous pouvez le constater, cette facette dispose de méthodes permettant de récupérer les divers symboles qui sont utilisés pour écrire les montants de la monnaie qu'elle décrit. Ainsi, la méthode decimal_point renvoie le caractère qui doit être utilisé en tant que séparateur du chiffre des unités de la partie fractionnaire des montants, si celle-ci doit être représentée. De même, la méthode thousands_sep renvoie le caractère qui doit être utilisé pour séparer les groupes de chiffres pour les grands montants, et la méthode grouping renvoie une chaîne contenant, dans chacun de ses caractères, le nombre de chiffres de chaque groupe. Ces méthodes sont donc semblables aux méthodes correspondantes de la facette numpunct. Le nombre de chiffres significatifs après la virgule utilisé pour cette monnaie peut être obtenue grâce à la méthode frac_digits. Ce n'est que si la valeur renvoyée par cette méthode est supérieure à 0 que le symbole de séparation des unités de la partie fractionnaire de la méthode decimal_point est utilisé.

La méthode curr_symbol permet d'obtenir le symbole monétaire de la monnaie. Ce symbole dépend de la valeur du paramètre template International. Si ce paramètre vaut true, le symbole monétaire renvoyé sera le symbole monétaire international. Dans le cas contraire, ce sera le symbole monétaire en usage dans le pays de circulation de la monnaie. La valeur du paramètre International pourra être obtenu grâce à la constante statique intl de la facette.

Les méthodes suivantes permettent de spécifier le format d'écriture des montants positifs et négatifs. Ces méthodes utilisent les définitions de constantes et de types de la classe de base money_base dont la facette moneypunct hérite. La classe money_base est déclarée comme suit dans l'en-tête locale :

class money_base
{
public:
    enum part
    {
        none, space, symbol, sign, value
    };
    struct pattern
    {
        char field[4];
    };
};

Cette classe contient la définition d'une énumération dont les valeurs permettent d'identifier les différentes composantes d'un montant, ainsi qu'une structure pattern qui contient un tableau de quatre caractères. Chacun de ces caractères peut prendre l'une des valeurs de l'énumération part. La structure pattern définit donc l'ordre dans lequel les composantes d'un montant doivent apparaître. Ce sont des motifs de ce genre qui sont renvoyés par les méthodes pos_format et neg_format, qui permettent d'obtenir respectivement le format des montants positifs et celui des montants négatifs.

Les différentes valeurs que peuvent prendre les éléments du motif pattern représentent chacune une partie de l'expression d'un montant. La valeur value représente bien entendu la valeur de ce montant, sign son signe et symbol le symbole monétaire. La valeur space permet d'insérer un espace dans l'expression d'un montant, mais les espaces ne peuvent pas être utilisés en début et en fin de montants. Enfin, la valeur none permet de ne rien mettre à la position où il apparaît dans le motif.

La manière d'écrire les montants positifs et négatifs varie grandement selon les pays. En général, il est courant d'utiliser le signe '-' pour signaler un montant négatif et aucun signe distinctif pour les montants positifs. Cependant, certains pays écrivent les montants négatifs entre parenthèses et la marque des montants négatifs n'est donc plus un simple caractère. Les méthodes positive_sign et negative_sign permettent d'obtenir les symboles à utiliser pour noter les montants positifs et négatifs. Elles retournent toutes les deux une chaîne de caractères, dont le premier est placé systématiquement à l'emplacement auquel la valeur sign a été affectée dans la chaîne de format renvoyée par les méthodes pos_format et neg_format. Les caractères résiduels, s'ils existent, sont placés à la fin de l'expression du montant complètement formatée. Ainsi, dans les locales pour lesquelles les montants négatifs sont écrits entre parenthèses, la chaîne renvoyée par la méthode negative_sign est « () », et pour les locales utilisant simplement le signe négatif, cette chaîne ne contient que le caractère '-'.

16.2.5.2. Les facettes de lecture et d'écriture des montants

Les facettes d'écriture et de lecture des montants sont sans doute les facettes standards les plus simples. En effet, elles ne disposent que de méthodes permettant d'écrire et de lire les montants sur les flux. Ces facettes sont respectivement les facettes money_put et money_get. Elles sont définies comme suit dans l'en-tête locale :

template <class charT, bool Intl = false,
    class OutputIterator = ostreambuf_iterator<charT> >
class money_put : public locale::facet
{
public:
// Les types de données :
    typedef charT               char_type;
    typedef OutputIterator      iter_type;
    typedef basic_string<charT> string_type;

// Le constructeur :
    explicit money_put(size_t refs = 0);

// Les méthodes d'écriture des montants :
    iter_type put(iter_type s, bool intl, ios_base &f,
        char_type remplissage, long double units) const;
    iter_type put(iter_type s, bool intl, ios_base &f,
        char_type remplissage, const string_type &digits) const;

// L'identificateur de la facette :
    static locale::id id;
};

template <class charT,
    class InputIterator = istreambuf_iterator<charT> >
class money_get : public locale::facet
{
public:
// Les types de données :
    typedef charT               char_type;
    typedef InputIterator       iter_type;
    typedef basic_string<charT> string_type;

// Le constructeur :
    explicit money_get(size_t refs = 0);

// Les méthodes de lecture des montants :
    iter_type get(iter_type s, iter_type end, bool intl,
        ios_base &f, ios_base::iostate &err,
        long double &units) const;
    iter_type get(iter_type s, iter_type end, bool intl,
        ios_base &f, ios_base::iostate &err,
        string_type &digits) const;
    static const bool intl = Intl;

// L'identificateur de la facette :
    static locale::id id;
};

Comme vous pouvez le constater, les méthodes d'écriture et de lecture put et get de ces facettes sont semblables aux méthodes correspondantes des facettes de gestion des nombres. Toutefois, elles se distinguent par un paramètre booléen complémentaire qui permet d'indiquer si les opérations de formatage doivent se faire en utilisant les conventions internationales d'écriture des montants. Les autres paramètres ont la même signification que pour les méthodes put et get des facettes de gestion des nombres. En particulier, l'itérateur fourni indique l'emplacement où les données doivent être écrites ou lues, et le flux d'entrée / sortie spécifié permet de récupérer les options de formatage des montants. L'une des options les plus utiles est sans doute l'option qui permet d'afficher la base des nombres, car, dans le cas des facettes de gestion des montants, elle permet d'activer ou non l'écriture du symbole monétaire. Enfin, les méthodes put et get sont fournies en deux exemplaires, un pour chaque type de donnée utilisable pour représenter les montants, à savoir les double et les chaînes de caractères.

16.2.6.1. La facette d'écriture des dates

La facette d'écriture des dates est déclarée comme suit dans l'en-tête locale :

template <class charT,
    class OutputIterator = ostreambuf_iterator<charT> >
class time_put : public locale::facet
{
public:
// Les types de données :
    typedef charT          char_type;
    typedef OutputIterator iter_type;

// Le constructeur :
    explicit time_put(size_t refs = 0);

// Les méthodes d'écriture des dates :
    iter_type put(iter_type s, ios_base &f, char_type remplissage, const tm *t,
        char format, char modificateur = 0) const;
    iter_type put(iter_type s, ios_base &f, char_type remplissage, const tm *t,
        const charT *debut_format, const charT *fin_format) const;

// L'identificateur de la facette :
      static locale::id id;
};

Cette facette dispose de deux surcharges de la méthode put permettant d'écrire une date sur un flux de sortie. La première permet d'écrire une date sur le flux de sortie dont un itérateur est donné en premier paramètre. Le formatage de la date se fait comme avec la fonction strftime de la bibliothèque C. Le paramètre modificateur ne doit pas être utilisé en général, sa signification n'étant pas précisée par la norme C++. La deuxième forme de la méthode put réalise également une écriture sur le flux, en prenant comme chaîne de format la première sous-chaîne commençant par le caractère '%' dans la chaîne indiquée par les paramètres debut_format et fin_format.

16.2.6.2. La facette de lecture des dates

La facette de lecture des dates permet de lire les dates dans le même format que celui utilisé par la fonction strftime de la bibliothèque C lorsque la chaîne de format vaut « %X » ou « %x ». Cette facette est déclarée comme suit dans l'en-tête locale :

template <class charT,
    class InputIterator = istreambuf_iterator<charT> >
class time_get : public locale::facet, public time_base
{
public:
// Les types de données :
    typedef charT         char_type;
    typedef InputIterator iter_type;

// Le constructeur :
    explicit time_get(size_t refs = 0);

// Les méthodes de gestion de la lecture des dates :
    iter_type get_time(iter_type s, iter_type end, ios_base &f,
        ios_base::iostate &err, tm *t)  const;
    iter_type get_date(iter_type s, iter_type end, ios_base &f,
        ios_base::iostate &err, tm *t)  const;
    iter_type get_weekday(iter_type s, iter_type end, ios_base &f,
        ios_base::iostate &err, tm *t) const;
    iter_type get_monthname(iter_type s, iter_type end, ios_base &f,
        ios_base::iostate &err, tm *t) const;
    iter_type get_year(iter_type s, iter_type end, ios_base &f,
        ios_base::iostate &err, tm *t) const;
    dateorder date_order() const;

// L'identificateur de la facette :
    static locale::id id;
};

Les différentes méthodes de cette facette permettent respectivement d'obtenir l'heure, la date, le jour de la semaine, le nom du mois et l'année d'une date dans le flux d'entrée spécifié par l'itérateur fourni en premier paramètre. Toutes ces données sont interprétées en fonction de la locale à laquelle la facette appartient.

Enfin, la méthode date_order permet d'obtenir l'une des valeurs de l'énumération définie dans la classe de base time_base et qui indique l'ordre dans lequel les composants jour / mois / année des dates apparaissent dans la locale de la facette. La classe de base time_base est déclarée comme suit dans l'en-tête locale :

class time_base
{
public:
    enum dateorder
    {
        no_order, dmy, mdy, ymd, ydm
    };
};

La signification des différentes valeurs de l'énumération est immédiate. La seule valeur nécessitant des explications complémentaires est la valeur no_order. Cette valeur est renvoyée par la méthode date_order si le format de date utilisé par la locale de la facette contient d'autres champs que le jour, le mois et l'année.