Standard library header <locale>

From cppreference.net

< cpp ‎ | header

Cet en-tête fait partie de la bibliothèque de traitement de texte .

Table des matières

Classes

locale

ensemble de facettes polymorphes qui encapsulent les différences culturelles
(classe)

Conversions de chaînes et de flux

wstring_convert

(C++11) (déprécié en C++17) (supprimé en C++26)

effectue des conversions entre une chaîne large et une chaîne d'octets
(modèle de classe)

wbuffer_convert

(C++11) (déprécié en C++17) (supprimé en C++26)

effectue la conversion entre un tampon de flux d'octets et un tampon de flux large
(modèle de classe)

Classes de base de catégorie de facette

ctype_base

définit les catégories de classification des caractères
(classe)

codecvt_base

définit les erreurs de conversion de caractères
(classe)

messages_base

définit le type de catalogue de messages
(classe)

time_base

définit les constantes de format de date
(classe)

money_base

définit les modèles de formatage monétaire
(classe)

Catégories de facettes

ctype

définit les tables de classification des caractères
(modèle de classe)

ctype <char>

spécialisation de std::ctype pour le type char
(spécialisation de modèle de classe)

codecvt

convertit entre les encodages de caractères, y compris UTF-8, UTF-16, UTF-32
(modèle de classe)

collate

définit la comparaison lexicographique et le hachage des chaînes
(modèle de classe)

messages

implémente la récupération de chaînes depuis des catalogues de messages
(modèle de classe)

time_get

analyse les valeurs de temps/date d'une séquence de caractères d'entrée vers std::tm
(modèle de classe)

time_put

formate le contenu de std::tm pour la sortie sous forme de séquence de caractères
(modèle de classe)

num_get

analyse les valeurs numériques d'une séquence de caractères d'entrée
(modèle de classe)

num_put

formate les valeurs numériques pour la sortie sous forme de séquence de caractères
(modèle de classe)

numpunct

définit les règles de ponctuation numérique
(modèle de classe)

money_get

analyse et construit une valeur monétaire à partir d'une séquence de caractères d'entrée
(modèle de classe)

money_put

formate une valeur monétaire pour la sortie sous forme de séquence de caractères
(modèle de classe)

moneypunct

définit les paramètres de formatage monétaire utilisés par std::money_get et std::money_put
(modèle de classe)

Catégories de facettes spécifiques aux paramètres régionaux

ctype_byname

représente le std::ctype fourni par le système pour les paramètres régionaux nommés
(modèle de classe)

codecvt_byname

représente le std::codecvt fourni par le système pour les paramètres régionaux nommés
(modèle de classe)

messages_byname

représente le std::messages fourni par le système pour les paramètres régionaux nommés
(modèle de classe)

collate_byname

représente le std::collate fourni par le système pour les paramètres régionaux nommés
(modèle de classe)

time_get_byname

représente le std::time_get fourni par le système pour les paramètres régionaux nommés
(modèle de classe)

time_put_byname

représente le std::time_put fourni par le système pour les paramètres régionaux nommés
(modèle de classe)

numpunct_byname

représente le std::numpunct fourni par le système pour les paramètres régionaux nommés
(modèle de classe)

moneypunct_byname

représente le std::moneypunct fourni par le système pour les paramètres régionaux nommés
(modèle de classe)

Fonctions

Locales et facettes

use_facet

obtient un facet d'une locale
(modèle de fonction)

has_facet

vérifie si une locale implémente un facet spécifique
(modèle de fonction)

Classification des caractères

isspace (std::locale)

vérifie si un caractère est classé comme espace blanc par une locale
(modèle de fonction)

isblank (std::locale)

(C++11)

vérifie si un caractère est classifié comme un caractère vide par une locale
(modèle de fonction)

iscntrl (std::locale)

vérifie si un caractère est classé comme caractère de contrôle par une locale
(modèle de fonction)

isupper (std::locale)

vérifie si un caractère est classé comme majuscule par une locale
(modèle de fonction)

islower (std::locale)

vérifie si un caractère est classé comme minuscule par une locale
(modèle de fonction)

isalpha (std::locale)

vérifie si un caractère est classé comme alphabétique selon une locale
(modèle de fonction)

isdigit (std::locale)

vérifie si un caractère est classé comme un chiffre par une locale
(modèle de fonction)

ispunct (std::locale)

vérifie si un caractère est classé comme ponctuation par une locale
(modèle de fonction)

isxdigit (std::locale)

vérifie si un caractère est classé comme un chiffre hexadécimal par une locale
(modèle de fonction)

isalnum (std::locale)

vérifie si un caractère est classé comme alphanumérique par une locale
(modèle de fonction)

isprint (std::locale)

vérifie si un caractère est classé comme imprimable par une locale
(modèle de fonction)

isgraph (std::locale)

vérifie si un caractère est classifié comme graphique par une locale
(modèle de fonction)

Conversions de caractères

toupper (std::locale)

convertit un caractère en majuscule en utilisant la facette ctype d'une locale
(modèle de fonction)

tolower (std::locale)

convertit un caractère en minuscule en utilisant la facette


          ctype

d'une locale
(modèle de fonction)

Synopsis

namespace std {
    // locale:
    class locale;
    template <class Facet> const Facet& use_facet(const locale&);
    template <class Facet> bool has_facet(const locale&) noexcept;
    // interfaces de commodité :
    template <class CharT> bool isspace (CharT c, const locale& loc);
    template <class CharT> bool isprint (CharT c, const locale& loc);
    template <class CharT> bool iscntrl (CharT c, const locale& loc);
    template <class CharT> bool isupper (CharT c, const locale& loc);
    template <class CharT> bool islower (CharT c, const locale& loc);
    template <class CharT> bool isalpha (CharT c, const locale& loc);
    template <class CharT> bool isdigit (CharT c, const locale& loc);
    template <class CharT> bool ispunct (CharT c, const locale& loc);
    template <class CharT> bool isxdigit(CharT c, const locale& loc);
    template <class CharT> bool isalnum (CharT c, const locale& loc);
    template <class CharT> bool isgraph (CharT c, const locale& loc);
    template <class CharT> CharT toupper(CharT c, const locale& loc);
    template <class CharT> CharT tolower(CharT c, const locale& loc);
    template <class Codecvt, class Elem = wchar_t,
              class Wide_alloc = std::allocator<Elem>,
        class Byte_alloc = std::allocator<char>> class wstring_convert;
    template <class Codecvt, class Elem = wchar_t,
              class Tr = char_traits<Elem>> class wbuffer_convert;
    // ctype:
    class ctype_base;
    template <class CharT> class ctype;
    template <>            class ctype<char>; // spécialisation
    template <class CharT> class ctype_byname;
    class codecvt_base;
    template <class internT, class externT, class stateT> class codecvt;
    template <class internT, class externT, class stateT> class codecvt_byname;
    // numeric:
    template <class CharT, class InputIter = istreambuf_iterator<CharT>> class num_get;
    template <class CharT, class OutputIter = osterambuf_iterator<CharT>> class num_put;
    template <class CharT> class numpunct;
    template <class CharT> class numpunct_byname;
    // collation:
    template <class CharT> class collate;
    template <class CharT> class collate_byname;
    // date et heure :
    class time_base;
    template <class CharT, class InputIter = istreambuf_iterator<CharT>>
        class time_get;
    template <class CharT, class InputIter> = istreambuf_iterator<CharT>>
        class time_get_byname;
    template <class CharT, class OutputIter> = ostreambuf_iterator<CharT>>
        class time_put;
    template <class CharT, class OutputIter> = ostreambuf_iterator<CharT>>
        class time_put_byname;
    // argent :
    class money_base;
    template <class CharT, class InputIter = istreambuf_iterator<CharT>> >
        class money_get;
    template <class CharT, class OutputIter = ostreambuf_iterator<CharT>> >
        class money_put;
    template <class CharT, bool Intl = false> class moneypunct;
    template <class CharT, bool Intl = false> class moneypunct_byname;
    // récupération des messages :
    class messages_base;
    template <class CharT> class messages;
    template <class CharT> class messages_byname;
}

Classe std::locale

class locale
{
public:
    // types :
    class facet;
    class id;
    typedef int category;
    static const category // les valeurs assignées ici sont uniquement à titre d'exposition
        none     = 0,
        collate  = 0x010,
        ctype    = 0x020,
        monetary = 0x040,
        numeric  = 0x080,
        time     = 0x100,
        messages = 0x200,
        all = collate | ctype | monetary | numeric | time | messages;
    // construction/copie/destruction :
    locale() noexcept;
    locale(const locale& other) noexcept;
    explicit locale(const char* std_name);
    explicit locale(const string& std_name);
    locale(const locale& other, const char* std_name, category);
    locale(const locale& other, const string& std_name, category);
    template <class Facet> locale(const locale& other, Facet* f);
    locale(const locale& other, const locale& one, category);
    ~locale();
    // non virtuel
    const locale& operator=(const locale& other) noexcept;
    template <class Facet> locale combine(const locale& other) const;
    // opérations sur les locales :
    basic_string<char>
    name() const;
    bool operator==(const locale& other) const;
    bool operator!=(const locale& other) const;
    template <class CharT, class Traits, class Allocator>
    bool operator()(const basic_string<CharT,Traits,Allocator>& s1,
                    const basic_string<CharT,Traits,Allocator>& s2) const;
    // objets de locale globaux :
    static
    locale global(const locale&);
    static const locale& classic();
};

Classe std::ctype_base

class ctype_base
{
public:
    typedef /*type-masque-de-bits*/ mask;
    // les valeurs numériques sont fournies à titre indicatif uniquement.
    static const mask space = 1 << 0;
    static const mask print = 1 << 1;
    static const mask cntrl = 1 << 2;
    static const mask upper = 1 << 3;
    static const mask lower = 1 << 4;
    static const mask alpha = 1 << 5;
    static const mask digit = 1 << 6;
    static const mask punct = 1 << 7;
    static const mask xdigit= 1 << 8;
    static const mask blank = 1 << 9;
    static const mask alnum = alpha | digit;
    static const mask graph = alnum | punct;
};

Classe std::ctype

template <class CharT>
class ctype : public locale::facet, public ctype_base
{
public:
    typedef CharT char_type;
    explicit ctype(size_t refs = 0);
    bool is(mask m, CharT c) const;
    const CharT* is(const CharT* low, const CharT* high, mask* vec) const;
    const CharT* scan_is(mask m,
                         const CharT* low, const CharT* high) const;
    const CharT* scan_not(mask m,
                          const CharT* low, const CharT* high) const;
    CharT        toupper(CharT c) const;
    const CharT* toupper(CharT* low, const CharT* high) const;
    CharT        tolower(CharT c) const;
    const CharT* tolower(CharT* low, const CharT* high) const;
    CharT        widen(char c) const;
    const char*  widen(const char* low, const char* high, CharT* to) const;
    char         narrow(CharT c, char dfault) const;
    const CharT* narrow(const CharT* low, const CharT*, char dfault,
                        char* to) const;
    static locale::id id;
protected:
    ~ctype();
    virtual bool do_is(mask m, CharT c) const;
    virtual const CharT* do_is(const CharT* low, const CharT* high,
                               mask* vec) const;
    virtual const CharT* do_scan_is(mask m,
                                    const CharT* low, const CharT* high) const;
    virtual const CharT* do_scan_not(mask m,
                                     const CharT* low, const CharT* high) const;
    virtual CharT do_toupper(CharT) const;
    virtual const CharT* do_toupper(CharT* low, const CharT* high) const;
    virtual CharT do_tolower(CharT) const;
    virtual const CharT* do_tolower(CharT* low, const CharT* high) const;
    virtual CharT do_widen(char) const;
    virtual const char*  do_widen(const char* low, const char* high,
                                  CharT* dest) const;
    virtual char do_narrow(CharT, char dfault) const;
    virtual const CharT* do_narrow(const CharT* low, const CharT* high,
                                   char dfault, char* dest) const;
};

La traduction n'a pas été effectuée car le contenu fourni est exclusivement du code C++ dans des balises `

`, conformément aux instructions de ne pas traduire le texte dans les balises ``, `` ou ` $`, et de préserver les termes spécifiques au C++.$

Classe std::ctype_byname

template <class CharT>
class ctype_byname : public ctype<CharT>
{
public:
    typedef typename ctype<CharT>::mask mask;
    explicit ctype_byname(const char*, size_t refs = 0);
    explicit ctype_byname(const string&, size_t refs = 0);
    protected:
    ~ctype_byname();
};

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++. Seul le texte environnant aurait été traduit s'il y en avait eu.

Classe std:: ctype < char >

template <> class ctype<char>
    : public locale::facet, public ctype_base
{
public:
    typedef char char_type;
    explicit ctype(const mask* tab = 0, bool del = false,
                   size_t refs = 0);
    bool is(mask m, char c) const;
    const char* is(const char* low, const char* high, mask* vec) const;
    const char* scan_is (mask m,
                         const char* low, const char* high) const;
    const char* scan_not(mask m,
                         const char* low, const char* high) const;
    char        toupper(char c) const;
    const char* toupper(char* low, const char* high) const;
    char        tolower(char c) const;
    const char* tolower(char* low, const char* high) const;
    char        widen(char c) const;
    const char* widen(const char* low, const char* high, char* to) const;
    char        narrow(char c, char dfault) const;
    const char* narrow(const char* low, const char* high, char dfault,
                       char* to) const;
    static locale::id id;
    static const size_t table_size = /* défini par l'implémentation */;
    const mask* table() const noexcept;
    static const mask* classic_table() noexcept;
protected:
    ~ctype();
    virtual char        do_toupper(char c) const;
    virtual const char* do_toupper(char* low, const char* high) const;
    virtual char        do_tolower(char c) const;
    virtual const char* do_tolower(char* low, const char* high) const;
    virtual char        do_widen(char c) const;
    virtual const char* do_widen(const char* low,
                                 const char* high,
                                 char* to) const;
    virtual char        do_narrow(char c, char dfault) const;
    virtual const char* do_narrow(const char* low,
                                  const char* high,
                                  char dfault, char* to) const;
};

Classe std::codecvt_base

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

Classe std::codecvt

template <class internT, class externT, class stateT>
class codecvt : public locale::facet, public codecvt_base
{
public:
    typedef internT intern_type;
    typedef externT extern_type;
    typedef stateT state_type;
    explicit codecvt(size_t refs = 0);
    result out(stateT& state,
               const internT* from, const internT* from_end,
               const internT*& from_next,
               externT* to, externT* to_end, externT*& to_next) const;
    result unshift(stateT& state, externT* to,
                   externT* to_end, externT*& to_next) const;
    result in(stateT& state,
              const externT* from, const externT* from_end,
              const externT*& from_next,
              internT* to,
              internT* to_end, internT*& to_next) const;
    int encoding() const noexcept;
    bool always_noconv() const noexcept;
    int length(stateT&, const externT* from, const externT* end,
               size_t max) const;
    int max_length() const noexcept;
    static locale::id id;
protected:
    ~codecvt();
    virtual result do_out(stateT& state,
                          const internT* from, const internT* from_end,
                          const internT*& from_next,
                          externT* to,
                          externT* to_end, externT*& to_next) const;
    virtual result do_in(stateT& state,
                         const externT* from, const externT* from_end,
                         const externT*& from_next,
                         internT* to,
                         internT* to_end, internT*& to_next) const;
    virtual result do_unshift(stateT& state,
                              externT* to,
                              externT* to_end, externT*& to_next) const;
    virtual int do_encoding() const noexcept;
    virtual bool do_always_noconv() const noexcept;
    virtual int do_length(stateT&, const externT* from,
                          const externT* end, size_t max) const;
    virtual int do_max_length() const noexcept;
};

Classe std::codecvt_byname

template <class internT, class externT, class stateT>
class codecvt_byname : public codecvt<internT, externT, stateT>
{
public:
    explicit codecvt_byname(const char*, size_t refs = 0);
    explicit codecvt_byname(const string&, size_t refs = 0);
protected:
    ~codecvt_byname();
};

Classe std::num_get

template <class CharT, class InputIter = istreambuf_iterator<CharT>>
class num_get : public locale::facet
{
public:
    typedef CharT           char_type;
    typedef InputIter   iter_type;
    explicit num_get(size_t refs = 0);
    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, long 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, unsigned long 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;
    static locale::id id;
protected:
    ~num_get();
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, bool& v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, long& v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, long long& v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, unsigned short& v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, unsigned int& v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, unsigned long& v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, unsigned long long& v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, float& v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, double& v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, long double& v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&,
                             ios_base::iostate& err, void*& v) const;
};

La traduction n'a pas été effectuée car le contenu se trouve entièrement à l'intérieur de balises `

` et contient exclusivement du code C++, conformément aux instructions qui stipulent de ne pas traduire le texte dans ces balises et de préserver les termes spécifiques au C++.

Classe std::num_put

template <class CharT, class OutputIter = ostreambuf_iterator<CharT>>
class num_put : public locale::facet
{
public:
    typedef CharT char_type;
    typedef OutputIter iter_type;
    explicit num_put(size_t refs = 0);
    iter_type put(iter_type s, ios_base& f, char_type fill,
                  bool v) const;
    iter_type put(iter_type s, ios_base& f, char_type fill,
                  long v) const;
    iter_type put(iter_type s, ios_base& f, char_type fill,
                  long long v) const;
    iter_type put(iter_type s, ios_base& f, char_type fill,
                  unsigned long v) const;
    iter_type put(iter_type s, ios_base& f, char_type fill,
                  unsigned long long v) const;
    iter_type put(iter_type s, ios_base& f, char_type fill,
                  double v) const;
    iter_type put(iter_type s, ios_base& f, char_type fill,
                  long double v) const;
    iter_type put(iter_type s, ios_base& f, char_type fill,
                  const void* v) const;
    static locale::id id;
protected:
    ~num_put();
    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                             bool v) const;
    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                             long v) const;
    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                             long long v) const;
    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                             unsigned long) const;
    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                             unsigned long long) const;
    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                             double v) const;
    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                             long double v) const;
    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                             const void* v) const;
};

Classe std::numpunct

template <class CharT>
class numpunct : public locale::facet
{
public:
    typedef CharT char_type;
    typedef basic_string<CharT> string_type;
    explicit numpunct(size_t refs = 0);
    char_type   decimal_point() const;
    char_type   thousands_sep() const;
    string      grouping()      const;
    string_type truename()      const;
    string_type falsename()     const;
    static locale::id id;
protected:
    ~numpunct(); // virtuel
    virtual char_type   do_decimal_point() const;
    virtual char_type   do_thousands_sep() const;
    virtual string      do_grouping()      const;
    virtual string_type do_truename()      const; // pour bool
    virtual string_type do_falsename()     const; // pour bool
};

Classe std::numpunct_byname

template <class CharT>
class numpunct_byname : public numpunct<CharT>
{
public:
    typedef CharT char_type;
    typedef basic_string<CharT> string_type;
    explicit numpunct_byname(const char*, size_t refs = 0);
    explicit numpunct_byname(const string&, size_t refs = 0);
protected:
    ~numpunct_byname();
};

Classe std::collate

template <class CharT>
class collate : public locale::facet
{
public:
    typedef CharT char_type;
    typedef basic_string<CharT> string_type;
    explicit collate(size_t refs = 0);
    int compare(const CharT* low1, const CharT* high1,
                const CharT* low2, const CharT* high2) const;
    string_type transform(const CharT* low, const CharT* high) const;
    long hash(const CharT* low, const CharT* high) const;
    static locale::id id;
protected:
    ~collate();
    virtual int do_compare(const CharT* low1, const CharT* high1,
                           const CharT* low2, const CharT* high2) const;
    virtual string_type do_transform(const CharT* low,
                                     const CharT* high) const;
    virtual long do_hash (const CharT* low, const CharT* high) const;
};

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant (s'il y en avait) aurait été traduit en français.

Classe std::collate_byname

template <class CharT>
class collate_byname : public collate<CharT>
{
public:
    typedef basic_string<CharT> string_type;
    explicit collate_byname(const char*, size_t refs = 0);
    explicit collate_byname(const string&, size_t refs = 0);
protected:
    ~collate_byname();
};

Classe std::time_base

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

Classe std::time_get

template <class CharT, class InputIter = istreambuf_iterator<CharT>>
class time_get : public locale::facet, public time_base
{
public:
    typedef CharT char_type;
    typedef InputIter iter_type;
    explicit time_get(size_t refs = 0);
    dateorder ordre_date() const;
    iter_type obtenir_temps(iter_type s, iter_type end, ios_base& f,
                       ios_base::iostate& err, tm* t) const;
    iter_type obtenir_date(iter_type s, iter_type end, ios_base& f,
                       ios_base::iostate& err, tm* t) const;
    iter_type obtenir_jour_semaine(iter_type s, iter_type end, ios_base& f,
                          ios_base::iostate& err, tm* t) const;
    iter_type obtenir_nom_mois(iter_type s, iter_type end, ios_base& f,
                            ios_base::iostate& err, tm* t) const;
    iter_type obtenir_annee(iter_type s, iter_type end, ios_base& f,
                       ios_base::iostate& err, tm* t) const;
    iter_type obtenir(iter_type s, iter_type end, ios_base& f,
                  ios_base::iostate& err, tm* t, char format,
                  char modificateur = 0) const;
    iter_type obtenir(iter_type s, iter_type end, ios_base& f,
                  ios_base::iostate& err, tm* t,
                  const char_type* fmt, const char_type* fmtend) const;
    static locale::id id;
protected:
    ~time_get();
    virtual dateorder faire_ordre_date() const;
    virtual iter_type faire_obtenir_temps(iter_type s, iter_type end, ios_base&,
                                  ios_base::iostate& err, tm* t) const;
    virtual iter_type faire_obtenir_date(iter_type s, iter_type end, ios_base&,
                                  ios_base::iostate& err, tm* t) const;
    virtual iter_type faire_obtenir_jour_semaine(iter_type s, iter_type end, ios_base&,
                                     ios_base::iostate& err, tm* t) const;
    virtual iter_type faire_obtenir_nom_mois(iter_type s, iter_type end, ios_base&,
                                       ios_base::iostate& err, tm* t) const;
    virtual iter_type faire_obtenir_annee(iter_type s, iter_type end, ios_base&,
                                  ios_base::iostate& err, tm* t) const;
    virtual iter_type faire_obtenir(iter_type s, iter_type end, ios_base& f,
                             ios_base::iostate& err, tm* t,
                             char format, char modificateur) const;
};

Classe std::time_get_byname

template <class CharT, class InputIter = istreambuf_iterator<CharT>>
class time_get_byname : public time_get<CharT, InputIter>
{
public:
    typedef time_base::dateorder dateorder;
    typedef InputIter iter_type;
    explicit time_get_byname(const char*, size_t refs = 0);
    explicit time_get_byname(const string&, size_t refs = 0);
protected:
    ~time_get_byname();
};

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant (s'il y en avait) aurait été traduit en français.

Classe std::time_put

template <class CharT, class OutputIter = ostreambuf_iterator<CharT>>
class time_put : public locale::facet
{
public:
    typedef CharT char_type;
    typedef OutputIter iter_type;
    explicit time_put(size_t refs = 0);
    // la fonction suivante est implémentée en termes d'autres fonctions membres
    iter_type put(iter_type s, ios_base& f, char_type fill, const tm* tmb,
                  const CharT* pattern, const CharT* pat_end) const;
    iter_type put(iter_type s, ios_base& f, char_type fill,
                  const tm* tmb, char format, char modifier = 0) const;
    static locale::id id;
protected:
    ~time_put();
    virtual iter_type do_put(iter_type s, ios_base&, char_type, const tm* t,
                             char format, char modifier) const;
};

Classe std::time_put_byname

template <class CharT, class OutputIter = ostreambuf_iterator<CharT>>
class time_put_byname : public time_put<CharT, OutputIter>
{
public:
    typedef CharT char_type;
    typedef OutputIter iter_type;
    explicit time_put_byname(const char*, size_t refs = 0);
    explicit time_put_byname(const string&, size_t refs = 0);
protected:
    ~time_put_byname();
};

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++. Seul le texte environnant aurait été traduit s'il y en avait eu.

Classe std::money_get

template <class CharT, class InputIter = istreambuf_iterator<CharT>>
class money_get : public locale::facet
{
public:
    typedef CharT char_type;
    typedef InputIter iter_type;
    typedef basic_string<CharT> string_type;
    explicit money_get(size_t refs = 0);
    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 locale::id id;
protected:
    ~money_get();
    virtual iter_type do_get(iter_type, iter_type, bool, ios_base&,
                             ios_base::iostate& err,
                             long double& units) const;
    virtual iter_type do_get(iter_type, iter_type, bool, ios_base&,
                             ios_base::iostate& err,
                             string_type& digits) const;
};

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant (s'il y en avait) aurait été traduit en français.

Classe std::money_put

template <class CharT, class OutputIter = ostreambuf_iterator<CharT>>
class money_put : public locale::facet
{
public:
    typedef CharT char_type;
    typedef OutputIter iter_type;
    typedef basic_string<CharT> string_type;
    explicit money_put(size_t refs = 0);
    iter_type put(iter_type s, bool intl, ios_base& f,
                  char_type fill, long double units) const;
    iter_type put(iter_type s, bool intl, ios_base& f,
                  char_type fill, const string_type& digits) const;
    static locale::id id;
protected:
    ~money_put();
    virtual iter_type do_put(iter_type, bool, ios_base&, char_type fill,
                             long double units) const;
    virtual iter_type do_put(iter_type, bool, ios_base&, char_type fill,
                             const string_type& digits) const;
};

Classe std::money_base

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

**Note:** Le code C++ n'a pas été traduit car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés selon les instructions. Seul le texte environnant aurait été traduit s'il y en avait eu.

Classe std::moneypunct

template <class CharT, bool International = false>
class moneypunct : public locale::facet, public money_base
{
public:
    typedef CharT char_type;
    typedef basic_string<CharT> string_type;
    explicit moneypunct(size_t refs = 0);
    CharT       decimal_point() const;
    CharT       thousands_sep() const;
    string      grouping()      const;
    string_type curr_symbol()   const;
    string_type positive_sign() const;
    string_type negative_sign() const;
    int         frac_digits()   const;
    pattern     pos_format()    const;
    pattern     neg_format()    const;
    static locale::id id;
    static const bool intl = International;
protected:
    ~moneypunct();
    virtual CharT       do_decimal_point() const;
    virtual CharT       do_thousands_sep() const;
    virtual string      do_grouping()      const;
    virtual string_type do_curr_symbol()   const;
    virtual string_type do_positive_sign() const;
    virtual string_type do_negative_sign() const;
    virtual int         do_frac_digits()   const;
    virtual pattern     do_pos_format()    const;
    virtual pattern     do_neg_format()    const;
};

*Note: Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant aurait été traduit s'il y en avait eu.*

Classe std::moneypunct_byname

template <class CharT, bool Intl = false>
class moneypunct_byname : public moneypunct<CharT, Intl>
{
public:
    typedef money_base::pattern pattern;
    typedef basic_string<CharT> string_type;
    explicit moneypunct_byname(const char*, size_t refs = 0);
    explicit moneypunct_byname(const string&, size_t refs = 0);
protected:
    ~moneypunct_byname();
};

Classe std::messages_base

class messages_base
{
public:
    typedef /* type entier signé non spécifié */ catalog;
};

Classe std::messages

template <class CharT>
class messages : public locale::facet, public messages_base {
public:
    typedef CharT char_type;
    typedef basic_string<CharT> string_type;
    explicit messages(size_t refs = 0);
    catalog open(const basic_string<char>& fn, const locale&) const;
    string_type get(catalog c, int set, int msgid,
                    const string_type& dfault) const;
    void close(catalog c) const;
    static locale::id id;
protected:
    ~messages();
    virtual catalog do_open(const basic_string<char>&, const locale&) const;
    virtual string_type do_get(catalog, int set, int msgid,
                               const string_type& dfault) const;
    virtual void do_close(catalog) const;
};

Classe std::messages_byname

template <class CharT>
class messages_byname : public messages<CharT>
{
public:
    typedef messages_base::catalog catalog;
    typedef basic_string<CharT> string_type;
    explicit messages_byname(const char*, size_t refs = 0);
    explicit messages_byname(const string&, size_t refs = 0);
protected:
    ~messages_byname();
};

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant aurait été traduit s'il y en avait eu.

Classe std::wstring_convert

template<class Codecvt, class Elem = wchar_t,
    class Wide_alloc = std::allocator<Elem>,
    class Byte_alloc = std::allocator<char>>
class wstring_convert
{
public:
    typedef std::basic_string<char, char_traits<char>, Byte_alloc> byte_string;
    typedef std::basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
    typedef typename Codecvt::state_type state_type;
    typedef typename wide_string::traits_type::int_type int_type;
    explicit wstring_convert(Codecvt* pcvt = new Codecvt);
    wstring_convert(Codecvt* pcvt, state_type state);
    explicit wstring_convert(const byte_string& byte_err,
                             const wide_string& wide_err = wide_string());
    ~wstring_convert();
    wstring_convert(const wstring_convert&) = delete;
    wstring_convert& operator=(const wstring_convert&) = delete;
    wide_string from_bytes(char byte);
    wide_string from_bytes(const char* ptr);
    wide_string from_bytes(const byte_string& str);
    wide_string from_bytes(const char* first, const char* last);
    byte_string to_bytes(Elem wchar);
    byte_string to_bytes(const Elem* wptr);
    byte_string to_bytes(const wide_string& wstr);
    byte_string to_bytes(const Elem* first, const Elem* last);
    size_t converted() const noexcept;
    state_type state() const;
private:
    byte_string byte_err_string; // exposition uniquement
    wide_string wide_err_string; // exposition uniquement
    Codecvt* cvtptr;             // exposition uniquement
    state_type cvtstate;         // exposition uniquement
    size_t cvtcount;             // exposition uniquement
};

Classe std::wbuffer_convert

template<class Codecvt,
    class Elem = wchar_t,
    class Tr = std::char_traits<Elem>>
class wbuffer_convert : public std::basic_streambuf<Elem, Tr>
{
public:
    typedef typename Codecvt::state_type state_type;
    explicit wbuffer_convert(std::streambuf* bytebuf = 0,
                             Codecvt* pcvt = new Codecvt,
                             state_type state = state_type());
    ~wbuffer_convert();
    wbuffer_convert(const wbuffer_convert&) = delete;
    wbuffer_convert& operator=(const wbuffer_convert&) = delete;
    std::streambuf* rdbuf() const;
    std::streambuf* rdbuf(std::streambuf* bytebuf);
    state_type state() const;
private:
    std::streambuf* bufptr; // exposition uniquement
    Codecvt* cvtptr;        // exposition uniquement
    state_type cvtstate;    // exposition uniquement
};

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement publié	Comportement corrigé
LWG 71	C++98	le paramètre end de `time_get::do_get_monthname` était manquant dans le synopsis	ajouté
LWG 75	C++98	le type du paramètre state des membres `length` et `do_length` de `codecvt` et `codecvt_byname` était const stateT & dans le synopsis	corrigé en stateT &
LWG 124	C++98	les types de retour des membres `do_scan_is` et `do_scan_not` de `codecvt_byname` étaient const char * dans le synopsis	corrigé en const charT *
LWG 228	C++98	toutes les fonctions membres virtuelles des facettes `XXX_byname` étaient listées dans les synopsis	ne liste que le destructeur (supprimé toutes les autres fonctions membres virtuelles)
LWG 268	C++98	les points-virgules suivant les déclarations du constructeur par défaut et du constructeur de copie de std::locale étaient manquants dans le synopsis	ajoutés
LWG 1298	C++98	il y avait une spécialisation explicite `ctype_byname` < char > dans le synopsis	supprimée

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Standard library header <locale>

Table des matières

Classes

Conversions de chaînes et de flux

Classes de base de catégorie de facette

Catégories de facettes

Catégories de facettes spécifiques aux paramètres régionaux

Fonctions

Locales et facettes

Classification des caractères

Conversions de caractères

Synopsis

Classe std::locale

Classe std::ctype_base

Classe std::ctype

Classe std::ctype_byname

Classe std:: ctype < char >

Classe std::codecvt_base

Classe std::codecvt

Classe std::codecvt_byname

Classe std::num_get

Classe std::num_put

Classe std::numpunct

Classe std::numpunct_byname

Classe std::collate

Classe std::collate_byname

Classe std::time_base

Classe std::time_get

Classe std::time_get_byname

Classe std::time_put

Classe std::time_put_byname

Classe std::money_get

Classe std::money_put

Classe std::money_base

Classe std::moneypunct

Classe std::moneypunct_byname

Classe std::messages_base

Classe std::messages

Classe std::messages_byname

Classe std::wstring_convert

Classe std::wbuffer_convert

Rapports de défauts