Standard library header <locale>

From cppreference.net

< cpp ‎ | header

Этот заголовок является частью библиотеки обработки текста .

Содержание

Классы

locale

набор полиморфных фасадов, инкапсулирующих культурные различия
(класс)

Преобразования строк и потоков

wstring_convert

(C++11) (устарело в C++17) (удалено в C++26)

выполняет преобразования между широкой строкой и байтовой строкой
(шаблон класса)

wbuffer_convert

(C++11) (устарело в C++17) (удалено в C++26)

выполняет преобразование между буфером потока байтов и буфером широкого потока
(шаблон класса)

Базовые классы категорий фасетов

ctype_base

определяет категории классификации символов
(класс)

codecvt_base

определяет ошибки преобразования символов
(класс)

messages_base

определяет тип каталога сообщений
(класс)

time_base

определяет константы формата даты
(класс)

money_base

определяет шаблоны денежного форматирования
(класс)

Категории фасетов

ctype

определяет таблицы классификации символов
(шаблон класса)

ctype <char>

специализация std::ctype для типа char
(специализация шаблона класса)

codecvt

преобразует между кодировками символов, включая UTF-8, UTF-16, UTF-32
(шаблон класса)

collate

определяет лексикографическое сравнение и хеширование строк
(шаблон класса)

messages

реализует извлечение строк из каталогов сообщений
(шаблон класса)

time_get

парсит значения времени/даты из входной последовательности символов в std::tm
(шаблон класса)

time_put

форматирует содержимое std::tm для вывода в виде символьной последовательности
(шаблон класса)

num_get

анализирует числовые значения из входной последовательности символов
(шаблон класса)

num_put

форматирует числовые значения для вывода в виде последовательности символов
(шаблон класса)

numpunct

определяет правила пунктуации для чисел
(шаблон класса)

money_get

анализирует и формирует денежное значение из входной последовательности символов
(шаблон класса)

money_put

форматирует денежное значение для вывода в виде последовательности символов
(шаблон класса)

moneypunct

определяет параметры форматирования денежных единиц, используемые std::money_get и std::money_put
(шаблон класса)

Категории фасетов, специфичные для локали

ctype_byname

представляет предоставляемую системой std::ctype для именованной локали
(шаблон класса)

codecvt_byname

представляет предоставляемую системой std::codecvt для именованной локали
(шаблон класса)

messages_byname

представляет предоставляемую системой std::messages для именованной локали
(шаблон класса)

collate_byname

представляет предоставляемую системой std::collate для именованной локали
(шаблон класса)

time_get_byname

представляет системную реализацию std::time_get для именованной локали
(шаблон класса)

time_put_byname

представляет предоставляемую системой std::time_put для именованной локали
(шаблон класса)

numpunct_byname

представляет предоставляемую системой std::numpunct для именованной локали
(шаблон класса)

moneypunct_byname

представляет предоставляемую системой std::moneypunct для именованной локали
(шаблон класса)

Функции

Локали и фацеты

use_facet

получает фасет из локали
(шаблон функции)

has_facet

проверяет, реализует ли локаль определенный фаcет
(шаблон функции)

Классификация символов

isspace (std::locale)

проверяет, классифицируется ли символ как пробельный в локали
(шаблон функции)

isblank (std::locale)

(C++11)

проверяет, классифицируется ли символ как пробельный символ в локали
(шаблон функции)

iscntrl (std::locale)

проверяет, классифицируется ли символ как управляющий символ в локали
(шаблон функции)

isupper (std::locale)

проверяет, классифицируется ли символ как заглавный в локали
(шаблон функции)

islower (std::locale)

проверяет, классифицируется ли символ как строчный в локали
(шаблон функции)

isalpha (std::locale)

проверяет, классифицируется ли символ как буквенный в данной локали
(шаблон функции)

isdigit (std::locale)

проверяет, классифицируется ли символ как цифра в локали
(шаблон функции)

ispunct (std::locale)

проверяет, классифицируется ли символ как знак пунктуации в локали
(шаблон функции)

isxdigit (std::locale)

проверяет, классифицируется ли символ как шестнадцатеричная цифра в локали
(шаблон функции)

isalnum (std::locale)

проверяет, классифицируется ли символ как буквенно-цифровой в локали
(шаблон функции)

isprint (std::locale)

проверяет, классифицируется ли символ как печатаемый в локали
(шаблон функции)

isgraph (std::locale)

проверяет, классифицируется ли символ как графический в локали
(шаблон функции)

Преобразования символов

toupper (std::locale)

преобразует символ в верхний регистр с использованием аспекта ctype локали
(шаблон функции)

tolower (std::locale)

преобразует символ в нижний регистр с использованием


          ctype

фасета локали
(шаблон функции)

Синопсис

namespace std {
    // локаль:
    class locale;
    template <class Facet> const Facet& use_facet(const locale&);
    template <class Facet> bool has_facet(const locale&) noexcept;
    // удобные интерфейсы:
    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>; // специализация
    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;
    // числовые:
    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;
    // дата и время:
    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;
    // деньги:
    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;
    // получение сообщений:
    class messages_base;
    template <class CharT> class messages;
    template <class CharT> class messages_byname;
}

Класс std::locale

class locale
{
public:
    // типы:
    class facet;
    class id;
    typedef int category;
    static const category // значения, присвоенные здесь, приведены только для демонстрации
        none     = 0,
        collate  = 0x010,
        ctype    = 0x020,
        monetary = 0x040,
        numeric  = 0x080,
        time     = 0x100,
        messages = 0x200,
        all = collate | ctype | monetary | numeric | time | messages;
    // конструкторы/копирование/уничтожение:
    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();
    // не виртуальный
    const locale& operator=(const locale& other) noexcept;
    template <class Facet> locale combine(const locale& other) const;
    // операции с локалями:
    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;
    // глобальные объекты локалей:
    static
    locale global(const locale&);
    static const locale& classic();
};

Класс std::ctype_base

class ctype_base
{
public:
    typedef /*bitmask-type*/ mask;
    // числовые значения приведены только для демонстрации.
    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;
};

Класс 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;
};

Класс 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();
};

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Класс 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 = /* определяемый реализацией */;
    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;
};

Класс std::codecvt_base

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

Класс 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;
};

Класс 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();
};

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Класс 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;
};

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений в соответствии с инструкциями. HTML-теги и атрибуты также сохранены в оригинальном виде.

Класс 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;
};

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Класс 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(); // виртуальный
    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; // для bool
    virtual string_type do_falsename()     const; // для bool
};

Класс 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();
};

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Класс 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;
};

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Класс 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();
};

Класс std::time_base

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

Класс 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 date_order() const;
    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;
    iter_type get(iter_type s, iter_type end, ios_base& f,
                  ios_base::iostate& err, tm* t, char format,
                  char modifier = 0) const;
    iter_type get(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 do_date_order() const;
    virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&,
                                  ios_base::iostate& err, tm* t) const;
    virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&,
                                  ios_base::iostate& err, tm* t) const;
    virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&,
                                     ios_base::iostate& err, tm* t) const;
    virtual iter_type do_get_monthname(iter_type s, iter_type end, ios_base&,
                                       ios_base::iostate& err, tm* t) const;
    virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&,
                                  ios_base::iostate& err, tm* t) const;
    virtual iter_type do_get(iter_type s, iter_type end, ios_base& f,
                             ios_base::iostate& err, tm* t,
                             char format, char modifier) const;
};

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений в соответствии с инструкциями. HTML-разметка и атрибуты также сохранены в оригинальном виде.

Класс 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();
};

Класс 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);
    // следующая функция реализована через другие функции-члены
    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;
};

Класс 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();
};

Класс 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;
};

Класс 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;
};

Класс std::money_base

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

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-разметка также сохранена в оригинальном виде.

Класс 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;
};

Класс 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();
};

Класс std::messages_base

class messages_base
{
public:
    typedef /* неопределённый знаковый целочисленный тип */ catalog;
};

Класс 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;
};

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений в соответствии с инструкциями. HTML-разметка и атрибуты также сохранены в оригинальном виде.

Класс 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();
};

Класс 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; // только для демонстрации
    wide_string wide_err_string; // только для демонстрации
    Codecvt* cvtptr;             // только для демонстрации
    state_type cvtstate;         // только для демонстрации
    size_t cvtcount;             // только для демонстрации
};

Класс 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; // только для демонстрации
    Codecvt* cvtptr;        // только для демонстрации
    state_type cvtstate;    // только для демонстрации
};

Отчёты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

DR	Применено к	Поведение в опубликованной версии	Корректное поведение
LWG 71	C++98	параметр end в `time_get::do_get_monthname` отсутствовал в синопсисе	добавлен
LWG 75	C++98	тип параметра state членов `length` и `do_length` в `codecvt` и `codecvt_byname` был const stateT & в синопсисе	исправлен на stateT &
LWG 124	C++98	типы возвращаемых значений членов `do_scan_is` и `do_scan_not` в `codecvt_byname` были const char * в синопсисе	исправлены на const charT *
LWG 228	C++98	все виртуальные функции-члены `XXX_byname` фацетов были перечислены в синопсисах	перечислен только деструктор (удалены все остальные виртуальные функции-члены)
LWG 268	C++98	точки с запятой после объявлений конструктора по умолчанию и конструктора копирования std::locale отсутствовали в синопсисе	добавлены
LWG 1298	C++98	присутствовала явная специализация `ctype_byname` < char > в синопсисе	удалена

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>

Содержание

Классы

Преобразования строк и потоков

Базовые классы категорий фасетов

Категории фасетов

Категории фасетов, специфичные для локали

Функции

Локали и фацеты

Классификация символов

Преобразования символов

Синопсис

Класс std::locale

Класс std::ctype_base

Класс std::ctype

Класс std::ctype_byname

Класс std:: ctype < char >

Класс std::codecvt_base

Класс std::codecvt

Класс std::codecvt_byname

Класс std::num_get

Класс std::num_put

Класс std::numpunct

Класс std::numpunct_byname

Класс std::collate

Класс std::collate_byname

Класс std::time_base

Класс std::time_get

Класс std::time_get_byname

Класс std::time_put

Класс std::time_put_byname

Класс std::money_get

Класс std::money_put

Класс std::money_base

Класс std::moneypunct

Класс std::moneypunct_byname

Класс std::messages_base

Класс std::messages

Класс std::messages_byname

Класс std::wstring_convert

Класс std::wbuffer_convert

Отчёты о дефектах