# <locale>

<head><title>&lt;locale&gt;</title></head>

# `<locale>`

* * *

**`codecvt· codecvt_base· codecvt_byname· collate· collate_byname· ctype· ctype<char>· ctype_base· ctype_byname· has_facet· locale· messages· messages_base· messages_byname· money_base· money_get· money_put· moneypunct· moneypunct_byname· num_get· num_put· numpunct· numpunct_byname· time_base· time_get· time_get_byname· time_put· time_put_byname· use_facet`**

**`isalnum· isalpha· iscntrl· isdigit· isgraph· islower· isprint· ispunct· isspace· isupper· isxdigit· tolower· toupper`**

* * *

Include the standard header **`<locale>`**
to define a host of template classes and functions that encapsulate
and manipulate [locales](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale.html#locale).

    namespace std {
    class locale;
    class ctype_base;
    template<class Elem>
        class ctype;
    template<>
        class ctype<char>;
    template<class Elem>
        class ctype_byname;
    class codecvt_base;
    template<class Elem, class Byte, class Statype>
        class codecvt;
    template<class Elem, class Byte, class Statype>
        class codecvt_byname;
    template<class Elem, class InIt>
        class num_get;
    template<class Elem, class OutIt>
        class num_put;
    template<class Elem>
        class numpunct;
    template<class Elem>
        class numpunct_byname;
    template<class Elem>
        class collate;
    template<class Elem>
        class collate_byname;
    class time_base;
    template<class Elem, class InIt>
        class time_get;
    template<class Elem, class InIt>
        class time_get_byname;
    template<class Elem, class OutIt>
        class time_put;
    template<class Elem, class OutIt>
        class time_put_byname;
    class money_base;
    template<class Elem, bool Intl, class InIt>
        class money_get;
    template<class Elem, bool Intl, class OutIt>
        class money_put;
    template<class Elem, bool Intl>
        class moneypunct;
    template<class Elem, bool Intl>
        class moneypunct_byname;
    class messages_base;
    template<class Elem>
        class messages;
    template<class Elem>
        class messages_byname;
    
            // TEMPLATE FUNCTIONS
    template<class Facet>
        bool has_facet(const locale& loc);
    template<class Facet>
        const Facet& use_facet(const locale& loc);
    template<class Elem>
        bool isspace(Elem ch, const locale& loc) const;
    template<class Elem>
        bool isprint(Elem ch, const locale& loc) const;
    template<class Elem>
        bool iscntrl(Elem ch, const locale& loc) const;
    template<class Elem>
        bool isupper(Elem ch, const locale& loc) const;
    template<class Elem>
        bool islower(Elem ch, const locale& loc) const;
    template<class Elem>
        bool isalpha(Elem ch, const locale& loc) const;
    template<class Elem>
        bool isdigit(Elem ch, const locale& loc) const;
    template<class Elem>
        bool ispunct(Elem ch, const locale& loc) const;
    template<class Elem>
        bool isxdigit(Elem ch, const locale& loc) const;
    template<class Elem>
        bool isalnum(Elem ch, const locale& loc) const;
    template<class Elem>
        bool isgraph(Elem ch, const locale& loc) const;
    template<class Elem>
        Elem toupper(Elem ch, const locale& loc) const;
    template<class Elem>
        Elem tolower(Elem ch, const locale& loc) const;
    }  // namespace stdCopy to clipboard

## `codecvt`

    template<class Elem, class Byte, class Statype>
        class codecvt
            : public locale::facet, codecvt_base {
    public:
        typedef Elem intern_type;
        typedef Byte extern_type;
        typedef Statype state_type;
        explicit codecvt(size_t refs = 0);
        result in(Statype& state,
            const Byte *first1, const Byte *last1,
                const Byte *next1,
            Elem *first2, Elem *last2, Elem *next2);
        result out(Statype& state,
            const Elem *first1, const Elem *last1,
                const Elem *next1,
            Byte *first2, Byte *last2, Byte *next2);
        result unshift(Statype& state,
            Byte *first2, Byte *last2, Byte *next2);
        bool always_noconv() const throw();
        int max_length() const throw();
        int length(const Statype& state,
            const Byte *first1, const Byte *last1,
                size_t _N2) const throw();
        int encoding() const throw();
        static locale::id id;
    protected:
        ~codecvt();
        virtual result do_in(Statype& state,
            const Byte *first1, const Byte *last1,
                const Byte *next1,
            Elem *first2, Elem *last2, Elem *next2);
        virtual result do_out(Statype& state,
            const Elem *first1, const Elem *last1,
                const Elem *next1,
            Byte *first2, Byte *last2, Byte *next2);
        virtual result do_unshift(Statype& state,
            Byte *first2, Byte *last2, Byte *next2);
        virtual bool do_always_noconv() const throw();
        virtual int do_max_length() const throw();
        virtual int do_encoding() const throw();
        virtual int do_length(const Statype& state,
            const Byte *first1, const Byte *last1,
                size_t len2) const throw();
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to control conversions between
a sequence of values of type `Elem`
and a sequence of values of type `Byte`.
The class `Statype`
characterizes the transformation -- and an object of class
`Statype` stores any necessary state information during
a conversion.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

The template versions of
`do_in` and
`do_out` always return
`codecvt_base::noconv`.
The Standard C++ library defines an explicit specialization, however,
that is more useful:

    template<>
        codecvt<wchar_t, char, mbstate_t>Copy to clipboard

which converts between `wchar_t` and *char* sequences.

### `codecvt::always_noconv`

    bool always_noconv() const throw();Copy to clipboard

The member function returns
`do_always_noconv()`.

### `codecvt::codecvt`

    explicit codecvt(size_t refs = 0);Copy to clipboard

The constructor initializes its
`locale::facet` base object with
`locale::facet(refs)`.

### `codecvt::do_always_noconv`

    virtual bool do_always_noconv() const throw();Copy to clipboard

The protected virtual member function returns true only if every call to
`do_in` or
`do_out` returns
`noconv`.
The template version always returns true.

### `codecvt::do_encoding`

    virtual int do_encoding() const throw();Copy to clipboard

The protected virtual member function returns:

- -1, if the encoding of sequences of type `extern_type`
is state dependent
- 0, if the encoding involves sequences of varying lengths
- `N`, if the encoding involves only sequences of length
`N`

### `codecvt::do_in`

    virtual result do_in(Statype state&,
        const Byte *first1, const Byte *last1, const Byte *next1,
        Elem *first2, Elem *last2, Elem *next2);Copy to clipboard

The protected virtual member function endeavors to convert the
source sequence at `[first1, last1)`
to a destination sequence that it
stores within `[first2, last2)`. It always stores in
`next1` a pointer to the first unconverted element in
the source sequence, and it always stores in `next2` a
pointer to the first unaltered element in the destination sequence.

`state` must represent the
[initial conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_charset.html#initial%20conversion%20state)
at the beginning of a new source sequence. The function alters its stored
value, as needed, to reflect the current state of a
successful conversion. Its stored value is otherwise unspecified.

The function returns:

- `codecvt_base::error`
if the source sequence is ill formed
- `codecvt_base::noconv`
if the function performs no conversion
- `codecvt_base::ok`
if the conversion succeeds
- `codecvt_base::partial`
if the source is insufficient, or if the destination is not large enough,
for the conversion to succeed

The template version always returns `noconv`.

### `codecvt::do_length`

    virtual int do_length(const Statype state&,
        const Byte *first1, const Byte *last1,
            size_t len2) const throw();Copy to clipboard

The protected virtual member function effectively calls
`do_in(mystate, first1,
last1, next1, buf, buf + len2, next2)`
for `mystate` a copy of `state`,
some buffer `buf`, and pointers
`next1` and `next2`. It
then returns `next2 - buf`.
(Thus, it counts the maximum number of conversions,
not greater than `len2`, defined by the
source sequence at `[first1, last1)`.)

The template version always returns the lesser of
`last1 - first1` and `len2`.

### `codecvt::do_max_length`

    virtual int do_max_length() const throw();Copy to clipboard

The protected virtual member function returns
the largest permissible value that can be returned by
`do_length(first1,
last1, 1)`, for arbitrary valid values of `first1`
and `last1`. (Thus, it is roughly analogous to the macro
`MB_CUR_MAX`, at least
when `Byte` is type `char`.)

The template version always returns 1.

### `codecvt::do_out`

    virtual result do_out(Statype state&,
        const Elem *first1, const Elem *last1,
            const Elem *next1,
        Byte *first2, Byte *last2, Byte *next2);Copy to clipboard

The protected virtual member function endeavors to convert the
source sequence at `[first1, last1)`
to a destination sequence that it
stores within `[first2, last2)`. It always stores in
`next1` a pointer to the first unconverted element in
the source sequence, and it always stores in `next2` a
pointer to the first unaltered element in the destination sequence.

`state` must represent the
[initial conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_charset.html#initial%20conversion%20state)
at the beginning of a new source sequence. The function alters its stored
value, as needed, to reflect the current state of a
successful conversion. Its stored value is otherwise unspecified.

The function returns:

- `codecvt_base::error`
if the source sequence is ill formed
- `codecvt_base::noconv`
if the function performs no conversion
- `codecvt_base::ok`
if the conversion succeeds
- `codecvt_base::partial`
if the source is insufficient, or if the destination is not large enough,
for the conversion to succeed

The template version always returns `noconv`.

### `codecvt::do_unshift`

    virtual result do_unshift(Statype state&,
        Byte *first2, Byte *last2, Byte *next2);Copy to clipboard

The protected virtual member function endeavors to convert the
source element `Elem(0)`
to a destination sequence that it
stores within `[first2, last2)`, except for the terminating
element `Byte(0)`. It always stores in `next2` a
pointer to the first unaltered element in the destination sequence.

`state` must represent the
[initial conversion state](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_charset.html#initial%20conversion%20state)
at the beginning of a new source sequence. The function alters its stored
value, as needed, to reflect the current state of a
successful conversion. Typically, converting the source element
`Elem(0)` leaves the current state in the initial conversion state.

The function returns:

- `codecvt_base::error`
if `state` represents an invalid state
- `codecvt_base::noconv`
if the function performs no conversion
- `codecvt_base::ok`
if the conversion succeeds
- `codecvt_base::partial`
if the destination is not large enough for the conversion to succeed

The template version always returns `noconv`.

### `codecvt::extern_type`

    typedef Byte extern_type;Copy to clipboard

The type is a synonym for the template parameter `Byte`.

### `codecvt::in`

    result in(Statype state&,
        const Byte *first1, const Byte *last1, const Byte *next1,
        Elem *first2, Elem *last2, Elem *next2);Copy to clipboard

The member function returns
`do_in(state, first1, last1,
next1, first2, last2, next2)`.

### `codecvt::intern_type`

    typedef Elem intern_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `codecvt::length`

    int length(const Statype state&,
        const Byte *first1, const Byte *last1,
            size_t len2) const throw();Copy to clipboard

The member function returns
`do_length(first1,
last1, len2)`.

### `codecvt::encoding`

    int encoding() const throw();Copy to clipboard

The member function returns
`do_encoding()`.

### `codecvt::max_length`

    int max_length() const throw();Copy to clipboard

The member function returns
`do_max_length()`.

### `codecvt::out`

    result out(Statype state&,
        const Elem *first1, const Elem *last1,
            const Elem *next1,
        Byte *first2, Byte *last2, Byte *next2);Copy to clipboard

The member function returns
`do_out(state, first1, last1,
next1, first2, last2, next2)`.

### `codecvt::state_type`

    typedef Statype state_type;Copy to clipboard

The type is a synonym for the template parameter `Statype`.

### `codecvt::unshift`

    result unshift(Statype state&,
        Byte *first2, Byte *last2, Byte *next2);Copy to clipboard

The member function returns
`do_unshift(state,
first2, last2, next2)`.

## `codecvt_base`

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

The class describes an enumeration common to all specializations of
template class `codecvt`. The enumeration
**`result`**
describes the possible return values from
`do_in` or
`do_out`:

- **`error`**
if the source sequence is ill formed
- **`noconv`**
if the function performs no conversion
- **`ok`**
if the conversion succeeds
- **`partial`**
if the destination is not large enough for the conversion to succeed

## `codecvt_byname`

    template<class Elem, class Byte, class Statype>
        class codecvt_byname
            : public codecvt<Elem, Byte, Statype> {
    public:
        explicit codecvt_byname(const char *locname,
            size_t refs = 0);
    protected:
        ~codecvt_byname();
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) of type
`codecvt<Elem, Byte, Statype>`.
Its behavior is determined by the
[named](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20name) locale `locname`.
The constructor initializes its base object with
`codecvt<Elem,
Byte, Statype>(refs)`.

## `collate`

    template<class Elem>
        class collate
            : public locale::facet {
    public:
        typedef Elem char_type;
        typedef basic_string<Elem> string_type;
        explicit collate(size_t refs = 0);
        int compare(const Elem *first1, const Elem *last1,
            const Elem *first2, const Elem *last2) const;
        string_type transform(const Elem *first,
            const Elem *last) const;
        long hash(const Elem *first, const Elem *last) const;
        static locale::id id;
    protected:
        ~collate();
        virtual int
            do_compare(const Elem *first1, const Elem *last1,
                const Elem *first2, const Elem *last2) const;
        virtual string_type do_transform(const Elem *first,
            const Elem *last) const;
        virtual long do_hash(const Elem *first,
            const Elem *last) const;
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to control comparisons
of sequences of type `Elem`.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

### `collate::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `collate::collate`

    explicit collate(size_t refs = 0);Copy to clipboard

The constructor initializes its base object with
`locale::facet(refs)`.

### `collate::compare`

    int compare(const Elem *first1, const Elem *last1,
        const Elem *first2, const Elem *last2) const;Copy to clipboard

The member function returns
`do_compare(first1, last1,
first2, last2)`.

### `collate::do_compare`

    virtual int do_compare(const Elem *first1, const Elem *last1,
        const Elem *first2, const Elem *last2) const;Copy to clipboard

The protected virtual member function compares the sequence at
`[first1, last1)` with the sequence at
`[first2, last2)`. It compares values
by applying `operator<`
between pairs of corresponding elements of type `Elem`.
The first sequence compares less if it has the smaller element in
the earliest unequal pair in the sequences, or if no unequal
pairs exist but the first sequence is shorter.

If the first sequence compares less than the second sequence,
the function returns -1. If the second sequence compares less, the function
returns +1. Otherwise, the function returns zero.

### `collate::do_hash`

    virtual long do_hash(const Elem *first,
        const Elem *last) const;Copy to clipboard

The protected virtual member function returns an integer derived
from the values of the elements in the sequence
`[first, last)`. Such a **hash** value can be useful,
for example, in distributing sequences pseudo randomly
across an array of lists.

### `collate::do_transform`

    virtual string_type do_transform(const Elem *first,
        const Elem *last) const;Copy to clipboard

The protected virtual member function returns an object of class
`string_type` whose controlled
sequence is a copy of the sequence `[first, last)`.
If a class derived from `collate<Elem>` overrides
`do_compare`, it should
also override `do_transform` to match. Put simply, two
transformed strings should yield the same result, when passed to
`collate::compare`, that you would get from passing the
untransformed strings to `compare` in the derived class.

### `collate::hash`

    long hash(const Elem *first, const Elem *last) const;Copy to clipboard

The member function returns
`do_hash(first, last)`.

### `collate::string_type`

    typedef basic_string<Elem> string_type;Copy to clipboard

The type describes a specialization of template class
`basic_string`
whose objects can store copies of the source sequence.

### `collate::transform`

    string_type transform(const Elem *first,
        const Elem *last) const;Copy to clipboard

The member function returns
`do_transform(first,
last)`.

## `collate_byname`

    template<class Elem>
        class collate_byname
            : public collate<Elem> {
    public:
        explicit collate_byname(const char *locname,
            size_t refs = 0);
    protected:
        ~collate_byname();
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) of type
`collate<Elem>`.
Its behavior is determined by the
[named](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20name) locale `locname`.
The constructor initializes its base object with
`collate<Elem>(refs)`.

## `ctype`

* * *

**`char_type· ctype· do_is· do_narrow· do_scan_is· do_scan_not· do_tolower· do_toupper· do_widen· is· narrow· scan_is· scan_not· tolower· toupper· widen`**

* * *

    template<class Elem>
        class ctype
            : public locale::facet, public ctype_base {
    public:
        typedef Elem char_type;
        explicit ctype(size_t refs = 0);
        bool is(mask maskval, Elem ch) const;
        const Elem *is(const Elem *first, const Elem *last,
            mask *dest) const;
        const Elem *scan_is(mask maskval, const Elem *first,
            const Elem *last) const;
        const Elem *scan_not(mask maskval, const Elem *first,
            const Elem *last) const;
        Elem toupper(Elem ch) const;
        const Elem *toupper(Elem *first, Elem *last) const;
        Elem tolower(Elem ch) const;
        const Elem *tolower(Elem *first, Elem *last) const;
        Elem widen(char byte) const;
        const char *widen(char *first, char *last,
            Elem *dest) const;
        char narrow(Elem ch, char dflt) const;
        const Elem *narrow(const Elem *first, const Elem *last,
            char dflt, char *dest) const;
        static locale::id id;
    protected:
        ~ctype();
        virtual bool do_is(mask maskval, Elem ch) const;
        virtual const Elem *do_is(const Elem *first, const Elem *last,
            mask *dest) const;
        virtual const Elem *do_scan_is(mask maskval, const Elem *first,
            const Elem *last) const;
        virtual const Elem *do_scan_not(mask maskval, const Elem *first,
            const Elem *last) const;
        virtual Elem do_toupper(Elem ch) const;
        virtual const Elem *do_toupper(Elem *first, Elem *last) const;
        virtual Elem do_tolower(Elem ch) const;
        virtual const Elem *do_tolower(Elem *first, Elem *last) const;
        virtual Elem do_widen(char byte) const;
        virtual const char *do_widen(char *first, char *last,
            Elem *dest) const;
        virtual char do_narrow(Elem ch, char dflt) const;
        virtual const Elem *do_narrow(const Elem *first,
            const Elem *last, char dflt, char *dest) const;
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to characterize
various properties of a ``character'' (element) of type `Elem`.
Such a facet also converts between sequences of `Elem`
elements and sequences of *char.*

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

The Standard C++ library defines two explicit specializations
of this template class:

- `ctype<char>`,
an explicit specialization whose differences are described separately
- `ctype<wchar_t>`, which treats elements as
[wide characters](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_charset.html#Wide-Character%20Encoding)

In this
[implementation](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_index.html#implementation),
other specializations of template class `ctype<Elem>`:

- convert a value `ch` of type `Elem` to
a value of type *char* with the expression `(char)ch`
- convert a value `byte` of type *char* to
a value of type `Elem` with the expression
`Elem(byte)`

All other operations are performed on *char* values the same
as for the explicit specialization `ctype<char>`.

### `ctype::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `ctype::ctype`

    explicit ctype(size_t refs = 0);Copy to clipboard

The constructor initializes its
`locale::facet` base object with
`locale::facet(refs)`.

### `ctype::do_is`

    virtual bool do_is(mask maskval, Elem ch) const;
    virtual const Elem *do_is(const Elem *first, const Elem *last,
        mask *dest) const;Copy to clipboard

The first protected member template function returns true if
`MASK(ch) & maskval` is nonzero,
where `MASK(ch)` designates the mapping between an element
value `ch` and its classification mask, of type
`mask`.
The name `MASK` is purely symbolic here; it is not
defined by the template class. For an object of class
`ctype<char>`,
the mapping is `tab[(unsigned char)(char)ch]`,
where `tab` is the stored pointer to the
[ctype mask table](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#ctype%20mask%20table).

The second protected member template function stores in
`dest[I]` the value
`MASK(first[I]) & maskval`, where
`I` ranges over the interval `[0, last - first)`.

### `ctype::do_narrow`

    virtual char do_narrow(Elem ch, char dflt) const;
    virtual const Elem *do_narrow(const Elem *first, const Elem *last,
        char dflt, char *dest) const;Copy to clipboard

The first protected member template function returns
`(char)ch`, or `dflt` if that expression
is undefined.

The second protected member template function stores in
`dest[I]` the value `do_narrow(first[I], dflt)`, for
`I` in the interval `[0, last - first)`.

### `ctype::do_scan_is`

    virtual const Elem *do_scan_is(mask maskval, const Elem *first,
        const Elem *last) const;Copy to clipboard

The protected member function returns the smallest pointer
`ptr` in the range `[first, last)` for which
`do_is(maskval, *ptr)` is true.
If no such value exists, the function returns `last`.

### `ctype::do_scan_not`

    virtual const Elem *do_scan_not(mask maskval, const Elem *first,
        const Elem *last) const;Copy to clipboard

The protected member function returns the smallest pointer
`ptr` in the range `[first, last)` for which
`do_is(maskval, *ptr)` is false.
If no such value exists, the function returns `last`.

### `ctype::do_tolower`

    virtual Elem do_tolower(Elem ch) const;
    virtual const Elem *do_tolower(Elem *first, Elem *last) const;Copy to clipboard

The first protected member template function returns
the lowercase character corresponding to `ch`,
if such a character exists. Otherwise, it returns `ch`.

The second protected member template function replaces each
element `first[I]`, for `I` in the interval
`[0, last - first)`, with `do_tolower(first[I])`.

### `ctype::do_toupper`

    virtual Elem do_toupper(Elem ch) const;
    virtual const Elem *do_toupper(Elem *first, Elem *last) const;Copy to clipboard

The first protected member template function returns
the uppercase character corresponding to `ch`,
if such a character exists. Otherwise, it returns `ch`.

The second protected member template function replaces each
element `first[I]`, for `I` in the interval
`[0, last - first)`, with `do_toupper(first[I])`.

### `ctype::do_widen`

    virtual Elem do_widen(char byte) const;
    virtual const char *do_widen(char *first, char *last,
        Elem *dest) const;Copy to clipboard

The first protected member template function returns
`Elem(byte)`.

The second protected member template function stores in
`dest[I]` the value `do_widen(first[I])`, for
`I` in the interval `[0, last - first)`.

### `ctype::is`

    bool is(mask maskval, Elem ch) const;
    const Elem *is(const Elem *first, const Elem *last,
        mask *dest) const;Copy to clipboard

The first member function returns
`do_is(maskval, ch)`.
The second member function returns `do_is(first, last, dest)`.

### `ctype::narrow`

    char narrow(Elem ch, char dflt) const;
    const Elem *narrow(const Elem *first, const Elem *last,
        char dflt, char *dest) const;Copy to clipboard

The first member function returns
`do_narrow(ch, dflt)`.
The second member function returns `do_narrow(first, last,
dflt, dest)`.

### `ctype::scan_is`

    const Elem *scan_is(mask maskval, const Elem *first,
        const Elem *last) const;Copy to clipboard

The member function returns
`do_scan_is(maskval,
first, last)`.

### `ctype::scan_not`

    const Elem *scan_not(mask maskval, const Elem *first,
        const Elem *last) const;Copy to clipboard

The member function returns
`do_scan_not(maskval,
first, last)`.

### `ctype::tolower`

    Elem tolower(Elem ch) const;
    const Elem *tolower(Elem *first, Elem *last) const;Copy to clipboard

The first member function returns
`do_tolower(ch)`.
The second member function returns
`do_tolower(first,
last)`.

### `ctype::toupper`

    Elem toupper(Elem ch) const;
    const Elem *toupper(Elem *first, Elem *last) const;Copy to clipboard

The first member function returns
`do_toupper(ch)`.
The second member function returns
`do_toupper(first,
last)`.

### `ctype::widen`

    Elem widen(char byte) const;
    const char *widen(char *first, char *last, Elem *dest) const;Copy to clipboard

The first member function returns
`do_widen(byte)`.
The second member function returns
`do_widen(first,
last, dest)`.

## `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 maskval, char ch) const;
        const char *is(const char *first, const char *last,
            mask *dest) const;
        const char *scan_is(mask maskval,
            const char *first, const char *last) const;
        const char *scan_not(mask maskval,
            const char *first, const char *last) const;
        char toupper(char ch) const;
        const char *toupper(char *first, char *last) const;
        char tolower(char ch) const;
        const char *tolower(char *first, char *last) const;
        char widen(char byte) const;
        const char *widen(char *first, char *last,
            char *dest) const;
        char narrow(char ch, char dflt) const;
        const char *narrow(const char *first,
            const char *last, char dflt, char *dest) const;
        static locale::id id;
    protected:
        ~ctype();
        virtual char do_toupper(char ch) const;
        virtual const char *do_toupper(char *first,
            char *last) const;
        virtual char do_tolower(char ch) const;
        virtual const char *do_tolower(char *first,
            char *last) const;
        virtual char do_widen(char ch) const;
        virtual const char *do_widen(char *first, char *last,
            char *dest) const;
        virtual char do_narrow(char ch, char dflt) const;
        virtual const char *do_narrow(const char *first,
            const char *last, char dflt, char *dest) const;
    
        const mask *table() const throw();
        static const mask *classic_table() const throw();
        static const size_t table_size;
        };Copy to clipboard

The class is an explicit specialization of template class
`ctype` for type *char.*
Hence, it describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to characterize
various properties of a ``character'' (element) of type *char.*
The explicit specialization differs from the template class in several
ways:

- An object of class `ctype<char>` stores a
pointer to the first element of a
**ctype mask table**, an array of
`UCHAR_MAX + 1`
elements of type
`ctype_base::mask`.
It also stores a boolean object that indicates whether the array
should be deleted (using `operator delete[]`)
when the `ctype<Elem>` object
is destroyed.
- Its sole public constructor lets you specify `tab`, the
ctype mask table, and `del`,
the boolean object that is true if the array
should be deleted when the `ctype<char>` object
is destroyed -- as well as the usual reference-count parameter
`refs`.
- The protected member function
`table()`
returns the stored ctype mask table.
- The static member object
`table_size`
specifies the minimum number of elements in a ctype mask table.
- The protected static member function
`classic_table()`
returns the ctype mask table appropriate to the
[`"C"` locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale.html#C%20locale).
- There are no protected virtual member functions
`do_is`,
`do_scan_is`, or
`do_scan_not`.
The corresponding public member functions perform the
equivalent operations themselves.
- The member functions
`do_narrow` and
`do_widen` simply
copy elements unaltered.

## `ctype_base`

    class ctype_base {
    public:
        typedef T1 mask;
        static const fmtflags space, print, cntrl,
            upper, lower, digit, punct,
            xdigit, alpha, alnum, graph;
        };Copy to clipboard

The class serves as a base class for facets of template class
`ctype`.
It defines the type
**`mask`**
in terms of the
[bitmask type](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_lib_cpp.html#bitmask%20type) `T1`.
All of the constant members except `alnum` and
`graph` are bitmask elements of this type.
Each of the constant members characterizes
a different way to classify characters, as defined by the functions
with similar names declared in the header
`<ctype.h>`.
The constants are:

- **`space`**
(function `isspace`)
- **`print`**
(function `isprint`)
- **`cntrl`**
(function `iscntrl`)
- **`upper`**
(function `isupper`)
- **`lower`**
(function `islower`)
- **`digit`**
(function `isdigit`)
- **`punct`**
(function `ispunct`)
- **`xdigit`**
(function `isxdigit`)
- **`alpha`**
(function `isalpha`)
- **`alnum`**
(function `isalnum`)
- **`graph`**
(function `isgraph`)

You can charaterize a combination of classifications by
ORing these constants. In particular, it is always true that
`alnum == (alpha | digit)` and
`graph == (alnum | punct)`.

## `ctype_byname`

    template<class Elem>
        class ctype_byname
            : public ctype<Elem> {
    public:
        explicit ctype_byname(const char *locname,
            size_t refs = 0);
    protected:
        ~ctype_byname();
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) of type
`ctype<Elem>`.
Its behavior is determined by the
[named](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20name) locale `locname`.
The constructor initializes its base object with
`ctype<Elem>(refs)`
(or the equivalent for base class
`ctype<char>`).

## `has_facet`

    template<class Facet>
        bool has_facet(const locale& loc);Copy to clipboard

The template function returns true if a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) of class `Facet`
is listed within the
[locale object](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20object) `loc`.

## `isalnum`

    template<class Elem>
        bool isalnum(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
alnum, ch)`.

## `isalpha`

    template<class Elem>
        bool isalpha(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
alpha, ch)`.

## `iscntrl`

    template<class Elem>
        bool iscntrl(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
cntrl, ch)`.

## `isdigit`

    template<class Elem>
        bool isdigit(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
digit, ch)`.

## `isgraph`

    template<class Elem>
        bool isgraph(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
graph, ch)`.

## `islower`

    template<class Elem>
        bool islower(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
lower, ch)`.

## `isprint`

    template<class Elem>
        bool isprint(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
print, ch)`.

## `ispunct`

    template<class Elem>
        bool ispunct(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
punct, ch)`.

## `isspace`

    template<class Elem>
        bool isspace(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
space, ch)`.

## `isupper`

    template<class Elem>
        bool isupper(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
upper, ch)`.

## `isxdigit`

    template<class Elem>
        bool isxdigit(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
is(ctype<Elem>::
xdigit, ch)`.

## `locale`

* * *

**`category· classic· combine· facet· global· id· locale· name· operator!=· operator()· operator==`**

* * *

    class locale {
    public:
        class facet;
        class id;
        typedef int category;
        static const category none, collate, ctype, monetary,
            numeric, time, messages, all;
        locale();
        explicit locale(const char *locname);
        locale(const locale& loc, const locale& other,
            category cat);
        locale(const locale& loc, const char *locname, category cat);
        template<class Facet>
            locale(const locale& loc, Facet *fac);
        template<class Facet>
            locale combine(const locale& loc) const;
        template<class Elem, class Tr, class Alloc>
            bool operator()(const basic_string<Elem, Tr, Alloc>& left,
                const basic_string<Elem, Tr, Alloc>& right) const;
        string name() const;
        bool operator==(const locale& right) const;
        bool operator!=(const locale& right) const;
        static locale global(const locale& right);
        static const locale& classic();
        };Copy to clipboard

The class describes a
**locale object** that encapsulates a
[locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale.html#locale). It represents
culture-specific information as a list of
**facets**. A facet is a
pointer to an object of a class
derived from class `facet`
that has a public object of the form:

    static locale::id id;Copy to clipboard

You can define an open-ended set of these facets. You can also
construct a locale object that designates an arbitrary number of
facets.

Predefined groups of these facets represent the
[locale categories](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale.html#locale%20category)
traditionally managed in the Standard C library by the function
`setlocale`.

Category **`collate`**
(`LC_COLLATE`)
includes the facets:

    collate<char>
    collate<wchar_t>Copy to clipboard

Category **`ctype`**
(`LC_CTYPE`)
includes the facets:

    ctype<char>
    ctype<wchar_t>
    codecvt<char, char, mbstate_t>
    codecvt<wchar_t, char, mbstate_t>Copy to clipboard

Category **`monetary`**
(`LC_MONETARY`)
includes the facets:

    moneypunct<char, false>
    moneypunct<wchar_t, false>
    moneypunct<char, true>
    moneypunct<wchar_t, true>
    money_get<char, istreambuf_iterator<char> >
    money_get<wchar_t, istreambuf_iterator<wchar_t> >
    money_put<char, ostreambuf_iterator<char> >
    money_put<wchar_t, ostreambuf_iterator<wchar_t> >Copy to clipboard

Category **`numeric`**
(`LC_NUMERIC`)
includes the facets:

    num_get<char, istreambuf_iterator<char> >
    num_get<wchar_t, istreambuf_iterator<wchar_t> >
    num_put<char, ostreambuf_iterator<char> >
    num_put<wchar_t, ostreambuf_iterator<wchar_t> >
    numpunct<char>
    numpunct<wchar_t>Copy to clipboard

Category **`time`**
(`LC_TIME`)
includes the facets:

    time_get<char, istreambuf_iterator<char> >
    time_get<wchar_t, istreambuf_iterator<wchar_t> >
    time_put<char, ostreambuf_iterator<char> >
    time_put<wchar_t, ostreambuf_iterator<wchar_t> >Copy to clipboard

Category **`messages`**
(`LC_MESSAGES`) includes the facets:

    messages<char>
    messages<wchar_t>Copy to clipboard

(The last category is required by Posix, but not the C Standard.)

Some of these predefined facets are used by the
[iostreams](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_lib_cpp.html#iostreams) classes,
to control the conversion of numeric values to and from
text sequences.

An object of class `locale` also stores a
**locale name** as an object of class
`string`. Using an
invalid locale name to construct a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) or a locale object
throws an object of class
`runtime_error`.
The stored locale name is `"*"` if the locale object
cannot be certain that a C-style locale corresponds exactly
to that represented by the object. Otherwise, you can establish
a matching locale within the Standard C library,
for the locale object `loc`, by calling
`setlocale(
LC_ALL,
loc.name.
c_str())`.

In this
[implementation](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_index.html#implementation),
you can also call the static member function:

    static locale empty();Copy to clipboard

to construct a locale object that has no facets. It is also a
**transparent locale** --
if the template functions
`has_facet` and
`use_facet` cannot find
the requested facet in a transparent locale, they consult first the
[global locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#global%20locale) and then,
if that is transparent, the
[classic locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#classic%20locale). Thus, you can write:

    cout.imbue(locale::empty());Copy to clipboard

Subsequent insertions to
`cout` are
mediated by the current state of the global locale.
You can even write:

    locale loc(locale::empty(), locale::classic(),
        locale::numeric);
    cout.imbue(loc);Copy to clipboard

Numeric formatting rules for subsequent insertions to
`cout` remain the same as in the
[C locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale.html#C%20locale),
even as the global locale supplies changing rules for inserting
dates and monetary amounts.

### `locale::category`

    typedef int category;
    static const category none, collate, ctype, monetary,
        numeric, time, messages, all;Copy to clipboard

The type is a synonym for *int* so that it can represent
any of the C [locale categories](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale.html#locale%20category).
It can represent a group of distinct elements of a
[bitmask type](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_lib_cpp.html#bitmask%20type)
(which is anonymous) local to class `locale`.
The elements are:

- **`collate`**,
corresponding to the C category
`LC_COLLATE`
- **`ctype`**,
corresponding to the C category
`LC_CTYPE`
- **`monetary`**,
corresponding to the C category
`LC_MONETARY`
- **`numeric`**,
corresponding to the C category
`LC_NUMERIC`
- **`time`**,
corresponding to the C category
`LC_TIME`
- **`messages`**,
corresponding to the Posix category
`LC_MESSAGES`

In addition, two useful values are:

- **`none`**, corresponding to none of
the C categories
- **`all`**,
corresponding to the C union of all categories
`LC_ALL`

You can represent an arbitrary group of categories by ORing
these constants, as in `monetary | time`.

### `locale::classic`

    static const locale& classic();Copy to clipboard

The static member function returns a locale object that represents the
**classic locale**,
which behaves the same as the
[C locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale.html#C%20locale) within the
Standard C library.

### `locale::combine`

    template<class Facet>
        locale combine(const locale& loc) const;Copy to clipboard

The member function returns a locale object that
replaces in (or adds to) `*this` the facet `Facet`
listed in `loc`.

### `locale::facet`

    class facet {
    protected:
        explicit facet(size_t refs = 0);
        virtual ~facet();
    private:
        facet(const facet&)          // not defined
        void operator=(const facet&) // not defined
        };Copy to clipboard

The member class serves as the base class for all
[locale facets](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet). Note that you
can neither copy nor assign an object of class `facet`.
You can construct and destroy objects derived from class
`locale::facet`, but not objects of the base class proper.
Typically, you construct an object `myfac` derived
from `facet` when you construct a locale, as in:

    locale loc(locale::classic(), new myfac);Copy to clipboard

In such cases, the constructor for the base class `facet`
should have a zero `refs` argument. When the object
is no longer needed, it is deleted. Thus, you supply a nonzero
`refs` argument only in those rare cases where you
take responsibility for the lifetime of the object.

### `locale::global`

    static locale global(const locale& loc);Copy to clipboard

The static member function stores a copy of `loc` as the
**global locale**. It also calls
`setlocale(
LC_ALL,
loc.name.
c_str())`,
to establishing a matching locale within the Standard C library.
The function then returns the previous global locale. At
[program startup](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_lib_over.html#program%20startup),
the global locale is the same as the
[classic locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#classic%20locale).

### `locale::id`

    class id {
    protected:
        id();
    private:
        id(const id&)             // not defined
        void operator=(const id&) // not defined
        };Copy to clipboard

The member class describes the static
member object required by each unique
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet). Note that you
can neither copy nor assign an object of class `id`.

### `locale::locale`

    locale();
    explicit locale(const char *locname);
    locale(const locale& loc, const locale& other,
        category cat);
    locale(const locale& loc, const char *locname, category cat);
    template<class Facet>
        locale(const locale& loc, Facet *fac);Copy to clipboard

The first constructor initializes the object to match the
[global locale](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#global%20locale). The second constructor
initializes all the
[locale categories](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale.html#locale%20category) to have behavior
consistent with the [locale name](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20name)
`locname`. The remaining constructors copy `loc`,
with the exceptions noted:

    locale(const locale& loc, const locale& other,
        category cat);Copy to clipboard

replaces from `other` those facets
corresponding to a category `C`
for which `C & cat` is nonzero.

    locale(const locale& loc, const char *locname, category cat);Copy to clipboard

replaces from `locale(locname, all)` those facets
corresponding to a category `C`
for which `C & cat` is nonzero.

    template<class Facet>
        locale(const locale& loc, Facet *fac);Copy to clipboard

replaces in (or adds to) `loc`
the facet `fac`,
if `fac` is not a null pointer.

If a locale name `locname` is a null pointer or otherwise
invalid, the function throws
`runtime_error`.

### `locale::name`

    string name() const;Copy to clipboard

The member function returns the stored
[locale name](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20name).

### `locale::operator!=`

    bool operator!=(const locale& right) const;Copy to clipboard

The member function returns `!(*this == right)`.

### `locale::operator()`

    template<class Elem, class Tr, class Alloc>
        bool operator()(const basic_string<Elem, Tr, Alloc>& left,
            const basic_string<Elem, Tr, Alloc>& right);Copy to clipboard

The member function effectively executes:

    const collate<Elem>& fac = use_fac<collate<Elem> >(*this);
    return (fac.compare(left.begin(), left.end(),
        right.begin(), right.end()) < 0);Copy to clipboard

Thus, you can use a locale object as a
[function object](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_functio2.html#function%20objects).

### `locale::operator==`

    bool operator==(const locale& right) const;Copy to clipboard

The member function returns true only if `*this` and `right`
are copies of the same locale or have the same name (other than
`"*"`).

## `messages`

    template<class Elem>
        class messages
            : public locale::facet, public messages_base {
    public:
        typedef Elem char_type;
        typedef basic_string<Elem> string_type;
        explicit messages(size_t refs = 0);
        catalog open(const string& catname,
            const locale& loc) const;
        string_type get(catalog catval, int set, int message,
            const string_type& dflt) const;
        void close(catalog catval) const;
        static locale::id id;
    protected:
        ~messages();
        virtual catalog do_open(const string& catname,
            const locale& loc) const;
        virtual string_type do_get(catalog catval, int set,
            int message, const string_type& dflt) const;
        virtual void do_close(catalog catval) const;
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to characterize
various properties of a
**message catalog**
that can supply messages represented as sequences of elements
of type `Elem`.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

### `messages::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `messages::close`

    void close(catalog catval) const;Copy to clipboard

The member function calls
`do_close(catval);`.

### `messages::do_close`

    virtual void do_close(catalog catval) const;Copy to clipboard

The protected member function closes the
[message catalog](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#message%20catalog) `catval`,
which must have been opened by an earlier call to
`do_open`.

### `messages::do_get`

    virtual string_type do_get(catalog catval, int set, int message,
        const string_type& dflt) const;Copy to clipboard

The protected member function endeavors to obtain a
message sequence from the
[message catalog](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#message%20catalog)
`catval`. It may make use of `set`,
`message`, and `dflt` in doing so.
It returns a copy of `dflt` on failure. Otherwise,
it returns a copy of the specified message sequence.

### `messages::do_open`

    virtual catalog do_open(const string& catname,
        const locale& loc) const;Copy to clipboard

The protected member function endeavors to open a
[message catalog](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#message%20catalog)
whose name is `catname`. It may make use of the locale
`loc` in doing so. It returns a value that compares
less than zero on failure. Otherwise, the returned value can
be used as the first argument on a later call to
`get`.
It should in any case be used as the argument on a later call to
`close`.

### `messages::get`

    string_type get(catalog catval, int set, int message,
        const string_type& dflt) const;Copy to clipboard

The member function returns
`do_get(catval, set, message, dflt);`.

### `messages::messages`

    explicit messages(size_t refs = 0);Copy to clipboard

The constructor initializes its base object
with `locale::facet(refs)`.

### `messages::open`

    catalog open(const string& catname,
        const locale& loc) const;Copy to clipboard

The member function returns
`do_open(catname, loc);`.

### `messages::string_type`

    typedef basic_string<Elem> string_type;Copy to clipboard

The type describes a specialization of template class
`basic_string`
whose objects can store copies of the message sequences.

## `messages_base`

    class messages_base {
        typedef int catalog;
        };Copy to clipboard

The class describes a type common to all specializations of
template class `messages`. The type
**`catalog`**
is a synonym for type *int* that
describes the possible return values from
`messages::do_open`.

## `messages_byname`

    template<class Elem>
        class messages_byname
            : public messages<Elem> {
    public:
        explicit messages_byname(const char *locname,
            size_t refs = 0);
    protected:
        ~messages_byname();
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) of type
`messages<Elem>`.
Its behavior is determined by the
[named](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20name) locale `locname`.
The constructor initializes its base object with
`messages<Elem>(refs)`.

## `money_base`

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

The class describes an enumeration and a structure
common to all specializations of
template class `moneypunct`.
The enumeration
**`part`**
describes the possible values in elements of the array
**`field`** in the structure
**`pattern`**.
The values of `part` are:

- **`none`**
to match zero or more spaces or generate nothing
- **`sign`**
to match or generate a positive or negative sign
- **`space`**
to match zero or more spaces or generate a space
- **`symbol`**
to match or generate a currency symbol
- **`value`**
to match or generate a monetary value

## `money_get`

    template<class Elem,
        class InIt = istreambuf_iterator<Elem> >
        class money_get
            : public locale::facet {
    public:
        typedef Elem char_type;
        typedef InIt iter_type;
        typedef basic_string<Elem> string_type;
        explicit money_get(size_t refs = 0);
        iter_type get(iter_type first, iter_type last,
            bool intl, ios_base& iosbase, ios_base::iostate& state,
                long double& val) const;
        iter_type get(iter_type first, iter_type last,
            bool intl, ios_base& iosbase, ios_base::iostate& state,
                string_type& val) const;
        static locale::id id;
    protected:
        ~money_get();
        virtual iter_type do_get(iter_type first,
            iter_type last, bool intl, ios_base& iosbase,
            ios_base::iostate& state, string_type& val) const;
        virtual iter_type do_get(iter_type first,
            iter_type last, bool intl, ios_base& iosbase,
            ios_base::iostate& state, long double& val) const;
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to control conversions
of sequences of type `Elem` to monetary values.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

### `money_get::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `money_get::do_get`

    virtual iter_type do_get(iter_type first, iter_type last,
        bool intl, ios_base& iosbase, ios_base::iostate& state,
            string_type& val) const;
    virtual iter_type do_get(iter_type first, iter_type last,
        bool intl, ios_base& iosbase, ios_base::iostate& state,
            long double& val) const;Copy to clipboard

The first virtual protected member function endeavors to match
sequential elements beginning at `first` in the sequence
`[first, last)` until it has recognized a complete, nonempty
**monetary input field**.
If successful, it converts this field to a sequence of one or
more decimal digits, optionally preceded by a minus sign
(`-`), to represent the amount and stores the result in the
`string_type` object `val`.
It returns an iterator
designating the first element beyond the monetary input field.
Otherwise, the function stores
an empty sequence in `val` and sets
`ios_base::failbit` in `state`.
It returns an iterator designating the first element beyond
any prefix of a valid monetary input field. In either case, if the
return value equals `last`, the function sets
`ios_base::eofbit` in `state`.

The second virtual protected member function behaves the same
as the first, except that if successful it converts
the optionally-signed digit sequence to a value of type *long double*
and stores that value in `val`.

The format of a monetary input field is determined by the
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) `fac`
returned by the (effective) call
`use_facet
<moneypunct<Elem, intl> >(iosbase.
getloc())`.
Specifically:

- `fac.neg_format()`
determines the order in which components of the field occur.
- `fac.curr_symbol()`
determines the sequence of elements that constitutes a currency symbol.
- `fac.positive_sign()`
determines the sequence of elements that constitutes a positive sign.
- `fac.negative_sign()`
determines the sequence of elements that constitutes a negative sign.
- `fac.grouping()`
determines how digits are grouped to the left of any decimal point.
- `fac.thousands_sep()`
determines the element that separates groups of digits to
the left of any decimal point.
- `fac.decimal_point()`
determines the element that separates the integer digits from the
fraction digits.
- `fac.frac_digits()`
determines the number of significant fraction digits to the right of
any decimal point.

If the sign string (`fac.negative_sign`
or `fac.positive_sign`) has more than one element, only
the first element is matched where the element equal to
**`money_base::sign`**
appears in the format pattern (`fac.neg_format`).
Any remaining
elements are matched at the end of the monetary input field.
If neither string has a first element
that matches the next element in the monetary input field,
the sign string is taken as empty and the sign is positive.

If `iosbase.flags() &
showbase` is nonzero,
the string `fac.curr_symbol` *must* match where the
element equal to
**`money_base::symbol`**
appears in the format pattern.
Otherwise, if `money_base::symbol` occurs at the end of
the format pattern, and if no elements of the sign string remain
to be matched, the currency symbol is *not* matched.
Otherwise, the currency symbol is *optionally* matched.

If no instances of `fac.thousands_sep()` occur in
the value portion of the monetary input field
(where the element equal to
**`money_base::value`**
appears in the format pattern), no grouping constraint is imposed. Otherwise,
any grouping constraints imposed by `fac.grouping()`
are enforced. Note that the resulting
digit sequence represents an integer whose
low-order `fac.frac_digits()` decimal digits are considered
to the right of the decimal point.

Zero or more
[white-space](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_lib_prin.html#white%20space) elements are matched
where an element equal to
**`money_base::space`** or
**`money_base::none`**
appears other than at the end of the format pattern.
Otherwise, no internal white space is matched.
An element `ch` is considered white space if
`use_facet
<ctype<Elem> >(iosbase.
getloc()).
is(ctype_base::
space, ch)` is true.

### `money_get::get`

    iter_type get(iter_type first, iter_type last,
        bool intl, ios_base& iosbase, ios_base::iostate& state,
            long double& val) const;
    iter_type get(iter_type first, iter_type last,
        bool intl, ios_base& iosbase, ios_base::iostate& state,
            string_type& val) const;Copy to clipboard

Both member functions return
`do_get(first, last, intl,
iosbase, state, val)`.

### `money_get::iter_type`

    typedef InIt iter_type;Copy to clipboard

The type is a synonym for the template parameter `InIt`.

### `money_get::money_get`

    explicit money_get(size_t refs = 0);Copy to clipboard

The constructor initializes its base object with
`locale::facet(refs)`.

### `money_get::string_type`

    typedef basic_string<Elem> string_type;Copy to clipboard

The type describes a specialization of template class
`basic_string`
whose objects can store sequences of elements from the source sequence.

## `money_put`

    template<class Elem,
        class OutIt = ostreambuf_iterator<Elem> >
        class money_put
            : public locale::facet {
    public:
        typedef Elem char_type;
        typedef OutIt iter_type;
        typedef basic_string<Elem> string_type;
        explicit money_put(size_t refs = 0);
        iter_type put(iter_type next, bool intl, ios_base& iosbase,
            Elem fill, long double& val) const;
        iter_type put(iter_type next, bool intl, ios_base& iosbase,
            Elem fill, string_type& val) const;
        static locale::id id;
    protected:
        ~money_put();
        virtual iter_type do_put(iter_type next, bool intl,
            ios_base& iosbase, Elem fill, string_type& val) const;
        virtual iter_type do_put(iter_type next, bool intl,
            ios_base& iosbase, Elem fill, long double& val) const;
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to control conversions
of monetary values to sequences of type `Elem`.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

### `money_put::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `money_put::do_put`

    virtual iter_type do_put(iter_type next, bool intl,
        ios_base& iosbase, Elem fill, string_type& val) const;
    virtual iter_type do_put(iter_type next, bool intl,
        ios_base& iosbase, Elem fill, long double& val) const;Copy to clipboard

The first virtual protected member function generates
sequential elements beginning at `next` to produce a
**monetary output field** from the
`string_type`
object `val`.
The sequence controlled by `val` must begin with
one or more decimal digits, optionally preceded by a minus sign
(`-`), which represents the amount.
The function returns an iterator designating the first element beyond
the generated monetary output field.

The second virtual protected member function behaves the same
as the first, except that it effectively first converts `val`
to a sequence of decimal digits, optionally preceded by a minus sign,
then converts that sequence as above.

The format of a monetary output field is determined by the
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) `fac`
returned by the (effective) call
`use_facet
<moneypunct<Elem, intl> >(iosbase.
getloc())`.
Specifically:

- `fac.pos_format()`
determines the order in which components of the field are generated
for a non-negative value.
- `fac.neg_format()`
determines the order in which components of the field are generated
for a negative value.
- `fac.curr_symbol()`
determines the sequence of elements to generate for a currency symbol.
- `fac.positive_sign()`
determines the sequence of elements to generate for a positive sign.
- `fac.negative_sign()`
determines the sequence of elements to generate for a negative sign.
- `fac.grouping()`
determines how digits are grouped to the left of any decimal point.
- `fac.thousands_sep()`
determines the element that separates groups of digits to
the left of any decimal point.
- `fac.decimal_point()`
determines the element that separates the integer digits from any
fraction digits.
- `fac.frac_digits()`
determines the number of significant fraction digits to the right of
any decimal point.

If the sign string (`fac.negative_sign`
or `fac.positive_sign`) has more than one element, only
the first element is generated where the element equal to
**`money_base::sign`**
appears in the format pattern (`fac.neg_format` or
`fac.pos_format`). Any remaining
elements are generated at the end of the monetary output field.

If `iosbase.flags() &
showbase` is nonzero,
the string `fac.curr_symbol` is generated where the
element equal to
**`money_base::symbol`**
appears in the format pattern.
Otherwise, no currency symbol is generated.

If no grouping constraints are imposed by `fac.grouping()`
(its first element has the value
`CHAR_MAX`)
then no instances of `fac.thousands_sep()` are generated
in the value portion of the monetary output field
(where the element equal to
**`money_base::value`**
appears in the format pattern).
If `fac.frac_digits()` is zero,
then no instance of `fac.decimal_point()` is generated
after the decimal digits. Otherwise, the resulting monetary output
field places the low-order `fac.frac_digits()`
decimal digits to the right of the decimal point.

[Padding](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#padding) occurs as for any numeric output field,
except that if `iosbase.flags() &
iosbase.internal` is nonzero, any internal
padding is generated where the element equal to
**`money_base::space`** or
**`money_base::none`**
appears in the format pattern, if it does appear.
At least one padding element occurs where an element equal to `space`
appears. Otherwise, internal padding occurs before the generated sequence.
The padding character is `fill`.

The function calls `iosbase.width(0)` to reset the
field width to zero.

### `money_put::put`

    iter_type put(iter_type next, bool intl, ios_base& iosbase,
        Elem fill, long double& val) const;
    iter_type put(iter_type next, bool intl, ios_base& iosbase,
        Elem fill, string_type& val) const;Copy to clipboard

Both member functions return
`do_put(next, intl,
iosbase, fill, val)`.

### `money_put::iter_type`

    typedef InIt iter_type;Copy to clipboard

The type is a synonym for the template parameter `OutIt`.

### `money_put::money_put`

    explicit money_put(size_t refs = 0);Copy to clipboard

The constructor initializes its base object with
`locale::facet(refs)`.

### `money_put::string_type`

    typedef basic_string<Elem> string_type;Copy to clipboard

The type describes a specialization of template class
`basic_string`
whose objects can store sequences of elements from the source sequence.

## `moneypunct`

* * *

**`char_type· curr_symbol· decimal_point· do_curr_symbol· do_decimal_point· do_frac_digits· do_grouping· do_neg_format· do_negative_sign· do_pos_format· do_positive_sign· do_thousands_sep· frac_digits· grouping· moneypunct· neg_format· negative_sign· pos_format· positive_sign· string_type· thousands_sep`**

* * *

    template<class Elem, bool Intl>
        class moneypunct
            : public locale::facet, public money_base {
    public:
        typedef Elem char_type;
        typedef basic_string<Elem> string_type;
        explicit moneypunct(size_t refs = 0);
        Elem decimal_point() const;
        Elem 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(  oonst;
        pattern neg_format() const;
        static const bool intl = Intl;
        static locale::id id;
    protected:
        ~moneypunct();
        virtual Elem do_decimal_point() const;
        virtual Elem 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;
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to desceibe the sequences
of type `Elem` used to represent a
**[monetary input field](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#monetary%20input%20field)** or a
**[monetary output field](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#monetary%20output%20field)**.
If the template parameter `Intl` is true, international
conventions are observed.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

The const static object
**`intl`** stores the value
of the template parameter `Intl`.

### `moneypunct::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `moneypunct::curr_symbol`

    string_type curr_symbol() const;Copy to clipboard

The member function returns
`do_curr_symbol()`.

### `moneypunct::decimal_point`

    Elem decimal_point() const;Copy to clipboard

The member function returns
`do_decimal_point()`.

### `moneypunct::do_curr_symbol`

    string_type do_curr_symbol() const;Copy to clipboard

The protected virtual member function returns
a locale-specific sequence of elements to use as a currency symbol.

### `moneypunct::do_decimal_point`

    Elem do_decimal_point() const;Copy to clipboard

The protected virtual member function returns
a locale-specific element to use as a decimal-point.

### `moneypunct::do_frac_digits`

    int do_frac_digits() const;Copy to clipboard

The protected virtual member function returns
a locale-specific count of the number of digits to display to the
right of any decimal point.

### `moneypunct::do_grouping`

    string do_grouping() const;Copy to clipboard

The protected virtual member function returns a locale-specific
rule for determining how digits
are grouped to the left of any decimal point.
The encoding is the same as for
`lconv::grouping`.

### `moneypunct::do_neg_format`

    pattern do_neg_format() const;Copy to clipboard

The protected virtual member function returns
a locale-specific rule for determining how to generate a
[monetary output field](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#monetary%20output%20field) for
a neeative amount. Each of the four elements of
`pattern::field`
can have the values:

- **`none`**
to match zero or more spaces or generate nothing
- **`sign`**
to match or generate a positive or negative sign
- **`space`**
to match zero or more spaces or generate a space
- **`symbol`**
to match or generate a currency symbol
- **`value`**
to match or generate a monetary value

Components of a monetary output field are generated
(and components of a
[monetary input field](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#monetary%20input%20field) are matched)
in the order in which these elements appear in `pattern::field`.
Each of the values `sign`, `symbol`,
`value`, and either `none` or `space`
must appear exactly once. The value `none` must not appear
first. The value `space` must not appear first or last.
If `Intl` is true, the order is `symbol`,
`sign`, `none`, then `value`.

The template version of `moneypunct<Elem, Intl>`
returns `{money_base::symbol, money_base::sign, money_base::value,
money_base::none}`.

### `moneypunct::do_negative_sign`

    string_type do_negative_sign() const;Copy to clipboard

The protected virtual member function returns
a locale-specific sequence of elements to use as a negative sign.

### `moneypunct::do_pos_format`

    pattern do_pos_format() const;Copy to clipboard

The protected virtual member function returns
a locale-specific rule for determining how to generate a
[monetary output field](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#monetary%20output%20field) for
a positive amount. (It also determines how to match the components of a
[monetary input field](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#monetary%20input%20field).)
The encoding is the same as for
`do_neg_format`.

The template version of `moneypunct<Elem, Intl>`
returns `{money_base::symbol, money_base::sign, money_base::value,
money_base::none}`.

### `moneypunct::do_positive_sign`

    string_type do_positive_sign() const;Copy to clipboard

The protected virtual member function returns
a locale-specific sequence of elements to use as a positive sign.

### `moneypunct::do_thousands_sep`

    Elem do_thousands_sep() const;Copy to clipboard

The protected virtual member function returns
a locale-specific element to use as a group separator to the left of
any decimal point.

### `moneypunct::frac_digits`

    int frac_digits() const;Copy to clipboard

The member function returns
`do_frac_digits()`.

### `moneypunct::grouping`

    string grouping() const;Copy to clipboard

The member function returns
`do_grouping()`.

### `moneypunct::moneypunct`

    explicit moneypunct(size_t refs = 0);Copy to clipboard

The constructor initializes its base object with
`locale::facet(refs)`.

### `moneypunct::neg_format`

    pattern neg_format() const;Copy to clipboard

The member function returns
`do_neg_format()`.

### `moneypunct::negative_sign`

    string_type negative_sign() const;Copy to clipboard

The member function returns
`do_negative_sign()`.

### `moneypunct::pos_format`

    pattern pos_format() const;Copy to clipboard

The member function returns
`do_pos_format()`.

### `moneypunct::positive_sign`

    string_type positive_sign() const;Copy to clipboard

The member function returns
`do_positive_sign()`.

### `moneypunct::string_type`

    typedef basic_string<Elem> string_type;Copy to clipboard

The type describes a specialization of template class
`basic_string`
whose objects can store copies of the punctuation sequences.

### `moneypunct::thousands_sep`

    Elem thousands_sep() const;Copy to clipboard

The member function returns
`do_thousands_sep()`.

## `moneypunct_byname`

    template<class Elem, bool Intl>
        class moneypunct_byname
            : public moneypunct<Elem, Intl> {
    public:
        explicit moneypunct_byname(const char *locname,
            size_t refs = 0);
    protected:
        ~moneypunct_byname();
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) of type
`moneypunct<Elem, Intl>`.
Its behavior is determined by the
[named](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20name) locale `locname`.
The constructor initializes its base object with
`moneypunct<Elem,
Intl>(refs)`.

## `num_get`

    template<class Elem, class InIt = istreambuf_iterator<Elem> >
        class num_get
            : public locale::facet {
    public:
        typedef Elem char_type;
        typedef InIt iter_type;
        explicit num_get(size_t refs = 0);
        iter_type get(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state,
                long& val) const;
        iter_type get(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state,
                unsigned long& val) const;
        iter_type get(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state,
                double& val) const;
        iter_type get(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state,
                long double& val) const;
        iter_type get(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state,
                void *& val) const;
        iter_type get(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state,
                bool& val) const;
        static locale::id id;
    protected:
        ~num_get();
        virtual iter_type
            do_get(iter_type first, iter_type last,
                ios_base& iosbase, ios_base::iostate& state,
                    long& val) const;
        virtual iter_type
            do_get(iter_type first, iter_type last,
                ios_base& iosbase, ios_base::iostate& state,
                    unsigned long& val) const;
        virtual iter_type
            do_get(iter_type first, iter_type last,
                ios_base& iosbase, ios_base::iostate& state,
                    double& val) const;
        virtual iter_type
            do_get(iter_type first, iter_type last,
                ios_base& iosbase, ios_base::iostate& state,
                    long double& val) const;
        virtual iter_type
            do_get(iter_type first, iter_type last,
                ios_base& iosbase, ios_base::iostate& state,
                    void *& val) const;
        virtual iter_type
            do_get(iter_type first, iter_type last,
                ios_base& iosbase, ios_base::iostate& state,
                    bool& val) const;
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to control conversions
of sequences of type `Elem` to numeric values.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

### `num_get::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `num_get::do_get`

    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            long& val) const;
    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            unsigned long& val) const;
    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            double& val) const;
    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            long double& val) const;
    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            void *& val) const;
    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            bool& val) const;Copy to clipboard

The first virtual protected member function endeavors to match
sequential elements beginning at `first` in the sequence
`[first, last)` until it has recognized a complete, nonempty
**integer input field**.
If successful, it converts this field to its equivalent value as
type *long,* and stores the result in `val`.
It returns an iterator
designating the first element beyond the numeric input field.
Otherwise, the function stores nothing in `val` and sets
`ios_base::failbit` in `state`.
It returns an iterator designating the first element beyond
any prefix of a valid integer input field. In either case, if the
return value equals `last`, the function sets
`ios_base::eofbit` in `state`.

The integer input field is converted by the same rules used by the
[scan functions](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_lib_scan.html#Scan%20Functions)
for matching and converting a series of *char* elements from a file.
(Each such *char* element is assumed to map to an equivalent element
of type `Elem` by a simple, one-to-one, mapping.) The equivalent
[scan conversion
specification](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_lib_scan.html#scan%20conversion%20specification) is determined as follows:

- If `iosbase.flags() &
ios_base::basefield ==
ios_base::oct`, the
conversion specification is `lo`.
- If `iosbase.flags() & ios_base::basefield ==
ios_base::hex`, the
conversion specification is `lx`.
- If `iosbase.flags() & ios_base::basefield == 0`, the
conversion specification is `li`.
- Otherwise, the conversion specification is `ld`.

The format of an integer input field is further determined by the
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) `fac`
returned by the call
`use_facet
<numpunct<Elem>(iosbase.
getloc())`.
Specifically:

- `fac.grouping()`
determines how digits are grouped to the left of any decimal point
- `fac.thousands_sep()`
determines the sequence that separates groups of digits to
the left of any decimal point

If no instances of `fac.thousands_sep()` occur in
the numeric input field, no grouping constraint is imposed. Otherwise,
any grouping constraints imposed by `fac.grouping()`
are enforced and separators are removed before the scan conversion
occurs.

The second virtual protected member function:

    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            unsigned long& val) const;Copy to clipboard

behaves the same
as the first, except that it replaces a conversion specification
of `ld` with `lu`. If successful it converts
the numeric input field to a value of type *unsigned long*
and stores that value in `val`.

The third virtual protected member function:

    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            double& val) const;Copy to clipboard

behaves the same
as the first, except that it endeavors to match a complete, nonempty
**floating-point input field**.
`fac.decimal_point()`
determines the sequence that separates the integer digits from the
fraction digits.
The equivalent scan conversion specifier is `lf`.

The fourth virtual protected member function:

    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            long double& val) const;Copy to clipboard

behaves the same the third, except that the equivalent
scan conversion specifier is `Lf`.

The fifth virtual protected member function:

    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            void *& val) const;Copy to clipboard

behaves the same the first, except that the equivalent
scan conversion specifier is `p`.

The sixth virtual protected member function:

    virtual iter_type do_get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            bool& val) const;Copy to clipboard

behaves the same
as the first, except that it endeavors to match a complete, nonempty
**boolean input field**.
If successful it converts
the boolean input field to a value of type `bool`
and stores that value in `val`.

A boolean input field takes one of two forms.
If `iosbase.flags() &
ios_base::boolalpha`
is false, it is the same as an integer input field, except that the
converted value must be either 0 (for false) or 1 (for true).
Otherwise, the sequence must match either
`fac.falsename()`
(for false), or
`fac.truename()`
(for true).

### `num_get::get`

    iter_type get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            long& val) const;
    iter_type get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            unsigned long& val) const;
    iter_type get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            double& val) const;
    iter_type get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            long double& val) const;
    iter_type get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            void *& val) const;
    iter_type get(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state,
            bool& val) const;Copy to clipboard

All member functions return
`do_get(first, last,
iosbase, state, val)`.

### `num_get::iter_type`

    typedef InIt iter_type;Copy to clipboard

The type is a synonym for the template parameter `InIt`.

### `num_get::num_get`

    explicit num_get(size_t refs = 0);Copy to clipboard

The constructor initializes its base object with
`locale::facet(refs)`.

## `num_put`

    template<class Elem, class OutIt = ostreambuf_iterator<Elem> >
        class num_put
            : public locale::facet {
    public:
        typedef Elem char_type;
        typedef OutIt iter_type;
        explicit num_put(size_t refs = 0);
        iter_type put(iter_type next, ios_base& iosbase,
            Elem fill, long val) const;
        iter_type put(iter_type next, ios_base& iosbase,
            Elem fill, unsigned long val) const;
        iter_type put(iter_type next, ios_base& iosbase,
            Elem fill, double val) const;
        iter_type put(iter_type next, ios_base& iosbase,
            Elem fill, long double val) const;
        iter_type put(iter_type next, ios_base& iosbase,
            Elem fill, const void *val) const;
        iter_type put(iter_type next, ios_base& iosbase,
            Elem fill, bool val) const;
        static locale::id id;
    protected:
        ~num_put();
        virtual iter_type do_put(iter_type next, ios_base& iosbase,
            Elem fill, long val) const;
        virtual iter_type do_put(iter_type next, ios_base& iosbase,
            Elem fill, unsigned long val) const;
        virtual iter_type do_put(iter_type next, ios_base& iosbase,
            Elem fill, double val) const;
        virtual iter_type do_put(iter_type next, ios_base& iosbase,
            Elem fill, long double val) const;
        virtual iter_type do_put(iter_type next, ios_base& iosbase,
            Elem fill, const void *val) const;
        virtual iter_type do_put(iter_type next, ios_base& iosbase,
            Elem fill, bool val) const;
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to control conversions
of numeric values to sequences of type `Elem`.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

### `num_put::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `num_put::do_put`

    virtual iter_type do_put(iter_type next, ios_base& iosbase,
        Elem fill, long val) const;
    virtual iter_type do_put(iter_type next, ios_base& iosbase,
        Elem fill, unsigned long val) const;
    virtual iter_type do_put(iter_type next, ios_base& iosbase,
        Elem fill, double val) const;
    virtual iter_type do_put(iter_type nextp ios_base& iosbase,
        Elem fill, long double val) const;
    virtual iter_type do_put(iter_type nextp ios_base& iosbase,
        Elem fill, const void *val) const;
    virtual iter_type do_put(iter_type next, ios_base& iosbase,
        Elem fill, bool val) const;Copy to clipboard

The first virtual protected member function generates
sequential elements beginning at `next` to produce an
**integer output field**
from the value of `val`.
The function returns an iterator designating the next place to
insert an element beyond the generated integer output field.

The integer output field is generated by the same rules used by the
[print functions](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_lib_prin.html#Print%20Functions)
for generating a series of *char* elements to a file.
(Each such *char* element is assumed to map to an equivalent element
of type `Elem` by a simple, one-to-one, mapping.) Where a
print function pads a field with either spaces or the digit `0`,
however, `do_put` instead uses `fill`.
The equivalent
[print conversion
specification](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_lib_prin.html#print%20conversion%20specification) is determined as follows:

- If `iosbase.flags() &
ios_base::basefield ==
ios_base::oct`, the
conversion specification is `lo`.
- If `iosbase.flags() & ios_base::basefield ==
ios_base::hex`, the
conversion specification is `lx`.
- Otherwise, the conversion specification is `ld`.

If `iosbase.width()`
is nonzero, a field width of this value is prepended. The
function then calls `iosbase.width(0)` to reset the
field width to zero.

**Padding** occurs only if
the minimum number of elements `N` required to
specify the output field is less than
`iosbase.width()`.
Such padding consists of a sequence of `N - width()` copies of
`fill`. Padding then occurs as follows:

- If `iosbase.flags() &
ios_base::adjustfield ==
ios_base::left`,
the flag `-` is prepended. (Padding occurs
after the generated text.)
- If `iosbase.flags() & ios_base::adjustfield ==
ios_base::internal`,
the flag `0` is prepended. (For a numeric output field,
padding occurs where the print functions pad with `0`.)
- Otherwise, no additional flag is prepended.
(Padding occurs before the generated sequence.)

Finally:

- If `iosbase.flags() &
ios_base::showpos`
is nonzero, the flag `+` is prepended to the conversion
specification.
- If `iosbase.flags() &
ios_base::showbase`
is nonzero, the flag `#` is prepended to the conversion
specification.

The format of an integer output field is further determined by the
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) `fac`
returned by the call
`use_facet
<numpunct<Elem>(iosbase.
getloc())`.
Specifically:

- `fac.grouping()`
determines how digits are grouped to the left of any decimal point
- `fac.thousands_sep()`
determines the sequence that separates groups of digits to
the left of any decimal point

If no grouping constraints are imposed by `fac.grouping()`
(its first element has the value
`CHAR_MAX`)
then no instances of `fac.thousands_sep()` are generated
in the output field. Otherwise, separators are inserted after the
print conversion occurs.

The second virtual protected member function:

    virtual iter_type do_put(iter_type next, ios_base& iosbase,
        Elem fill, unsigned long val) const;Copy to clipboard

behaves the same
as the first, except that it replaces a conversion specification
of `ld` with `lu`.

The third virtual protected member function:

    virtual iter_type do_put(iter_type next, ios_base& iosbase,
        Elem fill, double val) const;Copy to clipboard

behaves the same as the first, except that it produces a
**floating-point output field**
from the value of `val`.
`fac.decimal_point()`
determines the sequence that separates the integer digits from the
fraction digits.
The equivalent print conversion specification is determined as follows:

- If `(iosbase.flags() &
ios_base::floatfield) ==
ios_base::fixed`, the
conversion specification is `lf`.
- If `(iosbase.flags() & ios_base::floatfield) ==
ios_base::scientific`, the
conversion specification is `le`.
If `iosbase.flags() &
ios_base::uppercase`
is nonzero, `e` is replaced with `E`.
- Otherwise, the conversion specification is `lg`.
If `iosbase.flags() & ios_base::uppercase`
is nonzero, `g` is replaced with `G`.

If `(iosbase.flags() &
ios_base::floatfield) ==
ios_base::fixed`, or if
`iosbase.precision()`
is greater than zero, a precision with the value
`iosbase.precision()` is prepended to the conversion specification.
Any [padding](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#padding) behaves the same
as for an integer output field. The padding character is
`fill`. Finally:

- If `iosbase.flags() &
ios_base::showpos`
is nonzero, the flag `+` is prepended to the conversion
specification.
- If `iosbase.flags() &
ios_base::showpoint`
is nonzero, the flag `#` is prepended to the conversion
specification.

The fourth virtual protected member function:

    virtual iter_type do_put(iter_type next, ios_base& iosbase,
        Elem fill, long double val) const;Copy to clipboard

behaves the same the third, except that the qualifier
`l` in the conversion specification is replaced with
`L`.

The fifth virtual protected member function:

    virtual iter_type do_put(iter_type next, ios_base& iosbase,
        Elem fill, const void *val) const;Copy to clipboard

behaves the same the first, except that the conversion specification
is `p`, plus any qualifier needed to specify padding.

The sixth virtual protected member function:

    virtual iter_type do_put(iter_type next, ios_base& iosbase,
        Elem fill, bool val) const;Copy to clipboard

behaves the same
as the first, except that it generates a
**boolean output field**
from `val`.

A boolean output field takes one of two forms.
If `iosbase.flags() &
ios_base::boolalpha`
is false, the member function returns
`do_put(next, iosbase, fill, (long)val)`, which typically produces a
generated sequence of either `0` (for false)
or `1` (for true).
Otherwise, the generated sequence is either
`fac.falsename()`
(for false), or
`fac.truename()`
(for true).

### `num_put::put`

    iter_type put(iter_type next, ios_base& iosbase,
        Elem fill, long val) const;
    iter_type put(iter_type next, ios_base& iosbase,
        Elem fill, unsigned long val) const;
    iter_type put(iter_type iter_type next, ios_base& iosbase,
        Elem fill, double val) const;
    iter_type put(iter_type next, ios_base& iosbase,
        Elem fill, long double val) const;
    iter_type put(iter_type next, ios_base& iosbase,
        Elem fill, const void *val) const;
    iter_type put(iter_type next, ios_base& iosbase,
        Elem fill, bool val) const;Copy to clipboard

All member functions return
`do_put(next,
iosbase, fill, val)`.

### `num_put::iter_type`

    typedef InIt iter_type;Copy to clipboard

The type is a synonym for the template parameter `OutIt`.

### `num_put::num_put`

    explicit num_put(size_t refs = 0);Copy to clipboard

The constructor initializes its base object with
`locale::facet(refs)`.

## `numpunct`

* * *

**`char_type· decimal_point· do_decimal_point· do_falsename· do_grouping· do_truename· do_thousands_sep· falsename· grouping· numpunct· string_type· thousands_sep· truename`**

* * *

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

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to desceibe the sequences
of type `Elem` used to represent the input fields matched by
`num_get`
or the output fields generated by
`num_get`.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

### `numpunct::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `numpunct::decimal_point`

    Elem decimal_point() const;Copy to clipboard

The member function returns
`do_decimal_point()`.

### `numpunct::do_decimal_point`

    Elem do_decimal_point() const;Copy to clipboard

The protected virtual member function returns
a locale-specific element to use as a decimal-point.

### `numpunct::do_falsename`

    string_type do_falsename() const;Copy to clipboard

The protected virtual member function returns
a locale-specific sequence to use as a text representation of
the value false.

### `numpunct::do_grouping`

    string do_grouping() const;Copy to clipboard

The protected virtual member function returns a locale-specific
rule for determining how digits
are grouped to the left of any decimal point.
The encoding is the same as for
`lconv::grouping`.

### `numpunct::do_thousands_sep`

    Elem do_thousands_sep() const;Copy to clipboard

The protected virtual member function returns
a locale-specific element to use as a group separator to the left of
any decimal point.

### `numpunct::do_truename`

    string_type do_truename() const;Copy to clipboard

The protected virtual member function returns
a locale-specific sequence to use as a text representation of
the value true.

### `numpunct::falsename`

    string_type falsename() const;Copy to clipboard

The member function returns
`do_falsename()`.

### `numpunct::grouping`

    string grouping() const;Copy to clipboard

The member function returns
`do_grouping()`.

### `numpunct::numpunct`

    explicit numpunct(size_t refs = 0);Copy to clipboard

The constructor initializes its base object with
`locale::facet(refs)`.

### `numpunct::string_type`

    typedef basic_string<Elem> string_type;Copy to clipboard

The type describes a specialization of template class
`basic_string`
whose objects can store copies of the punctuation sequences.

### `numpunct::thousands_sep`

    Elem thousands_sep() const;Copy to clipboard

The mmmber function returns
`do_thousands_sep()`.

### `numpunct::truename`

    string_type falsename() const;Copy to clipboard

The member function returns
`do_truename()`.

## `numpunct_byname`

    template<class Elem>
        class numpunct_byname
            : public numpunct<Elem> {
    public:
        explicit numpunct_byname(const char *locname,
            size_t refs = 0);
    protected:
        ~numpunct_byname();
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) of type
`numpunct<Elem>`.
Its behavior is determined by the
[named](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20name) locale `locname`.
The constructor initializes its base object with
`numpunct<Elem>(refs)`.

## `time_base`

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

The class serves as a base class for facets of template class
`time_get`.
It defines just the enumerated type
**`dateorder`**
and several constants of this type. Each of the constants characterizes
a different way to order the components of a date.
The constants are:

- **`no_order`**
specifies no particular order.
- **`dmy`**
specifies the order day, month, then year, as in
`2 December 1979`.
- **`mdy`**
specifies the order month, day, then year, as in
`December 2, 1979`.
- **`ymd`**
specifies the order year, month, then day, as in
`1979/12/2`.
- **`ydm`**
specifies the order year, day, then month, as in
`1979: 2 Dec`.

## `time_get`

    template<class Elem, class InIt = istreambuf_iterator<Elem> >
        class time_get
            : public locale::facet, time_base {
    public:
        typedef Elem char_type;
        typedef InIt iter_type;
        explicit time_get(size_t refs = 0);
        dateorder date_order() const;
        iter_type get_time(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state, tm *pt) const;
        iter_type get_date(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state, tm *pt) const;
        iter_type get_weekday(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state, tm *pt) const;
        iter_type get_month(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state, tm *pt) const;
        iter_type get_year(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state, tm *pt) const;
        static locale::id id;
    protected:
        ~time_get();
        virtual dateorder do_date_order() const;
        virtual iter_type
            do_get_time(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state, tm *pt) const;
        virtual iter_type
            do_get_date(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state, tm *pt) const;
        virtual iter_type
            do_get_weekday(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state, tm *pt) const;
        virtual iter_type
            do_get_month(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state, tm *pt) const;
        virtual iter_type
            do_get_year(iter_type first, iter_type last,
            ios_base& iosbase, ios_base::iostate& state, tm *pt) const;
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to control conversions
of sequences of type `Elem` to time values.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

### `time_get::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `time_get::date_order`

    dateorder date_order() const;Copy to clipboard

The member function returns
`date_order()`.

### `time_get::do_date_order`

    virtual dateorder do_date_order() const;Copy to clipboard

The virtual protected member function returns a value of type
`time_base::dateorder`,
which describes the order in which date components are matched by
`do_get_date`.

### `time_get::do_get_date`

    virtual iter_type
        do_get_date(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state, tm *pt) const;Copy to clipboard

The virtual protected member function endeavors to match
sequential elements beginning at `first` in the sequence
`[first, last)` until it has recognized a complete, nonempty
**date input field**.
If successful, it converts this field to its equivalent value as
the components
`tm::tm_mon`,
`tm::tm_day`, and `tm::tm_year`,
and stores the results in `pt->tm_mon`,
`pt->tm_day` and `pt->tm_year`, respectively.
It returns an iterator
designating the first element beyond the date input field.
Otherwise, the function sets
`ios_base::failbit` in `state`.
It returns an iterator designating the first element beyond
any prefix of a valid date input field. In either case, if the
return value equals `last`, the function sets
`ios_base::eofbit` in `state`.

In this [implementation](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_index.html#implementation),
the date input field is assumed to have three fields:

- a month, which is either a sequence of decimal digits whose
corresponding numeric value must be in the range [1, 12],
giving the month plus one, or the sequence matched by
`get_month`, giving
the month
- a day, which is a sequence of decimal digits whose
corresponding numeric value must be in the range [1, 31],
giving the day of the month
- a year, which is the sequence matched by
`get_year`, giving
the year

The fields are separated by optional spaces,
followed by an optional colon, comma, or slash,
followed by optional spaces. The order of the fields is as specified by
`time_get::date_order()`,
except that the value `no_order` is taken as `mdy` and any
sequence matched by `get_month` is always taken as a month.

### `time_get::do_get_month`

    virtual iter_type
        do_get_month(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state, tm *pt) const;Copy to clipboard

The virtual protected member function endeavors to match
sequential elements beginning at `first` in the sequence
`[first, last)` until it has recognized a complete, nonempty
**month input field**.
If successful, it converts this field to its equivalent value as
the component
`tm::tm_mon`,
and stores the result in `pt->tm_mon`.
It returns an iterator
designating the first element beyond the month input field.
Otherwise, the function sets
`ios_base::failbit` in `state`.
It returns an iterator designating the first element beyond
any prefix of a valid month input field. In either case, if the
return value equals `last`, the function sets
`ios_base::eofbit` in `state`.

The month input field is a sequence that matches the longest
of a set of locale-specific sequences, such as: `Jan`,
`January`, `Feb`, `February`, etc.
The converted value is the number of months since January.

### `time_get::do_get_time`

    virtual iter_type
        do_get_time(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state, tm *pt) const;Copy to clipboard

The virtual protected member function endeavors to match
sequential elements beginning at `first` in the sequence
`[first, last)` until it has recognized a complete, nonempty
**time input field**.
If successful, it converts this field to its equivalent value as
the components
`tm::tm_hour`,
`tm::tm_min`, and `tm::tm_sec`,
and stores the results in `pt->tm_hour`,
`pt->tm_min` and `pt->tm_sec`, respectively.
It returns an iterator
designating the first element beyond the time input field.
Otherwise, the function sets
`ios_base::failbit` in `state`.
It returns an iterator designating the first element beyond
any prefix of a valid time input field. In either case, if the
return value equals `last`, the function sets
`ios_base::eofbit` in `state`.

In this [implementation](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_index.html#implementation),
the time input field has the form `HH:MM:SS`, where:

- `HH` is a sequence of decimal digits whose
corresponding numeric value must be in the range [0, 24), giving
the hour of the day.
- `MM` is a sequence of decimal digits whose
corresponding numeric value must be in the range [0, 60), giving
the minutes past the hour.
- `SS` is a sequence of decimal digits whose
corresponding numeric value must be in the range [0, 60), giving
the seconds past the minute.
- The literal colons must match corresponding elements
in the input sequence.

### `time_get::do_get_weekday`

    virtual iter_type
        do_get_weekday(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state, tm *pt) const;Copy to clipboard

The virtual protected member function endeavors to match
sequential elements beginning at `first` in the sequence
`[first, last)` until it has recognized a complete, nonempty
**weekday input field**.
If successful, it converts this field to its equivalent value as
the component
`tm::tm_wday`,
and stores the result in `pt->tm_wday`.
It returns an iterator
designating the first element beyond the weekday input field.
Otherwise, the function sets
`ios_base::failbit` in `state`.
It returns an iterator designating the first element beyond
any prefix of a valid weekday input field. In either case, if the
return value equals `last`, the function sets
`ios_base::eofbit` in `state`.

The weekday input field is a sequence that matches the longest
of a set of locale-specific sequences, such as: `Sun`,
`Sunday`, `Mon`, `Monday`, etc.
The converted value is the number of days since Sunday.

### `time_get::do_get_year`

    virtual iter_type
        do_get_year(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state, tm *pt) const;Copy to clipboard

The virtual protected member function endeavors to match
sequential elements beginning at `first` in the sequence
`[first, last)` until it has recognized a complete, nonempty
**year input field**.
If successful, it converts this field to its equivalent value as
the component
`tm::tm_year`,
and stores the result in `pt->tm_year`.
It returns an iterator
designating the first element beyond the year input field.
Otherwise, the function sets
`ios_base::failbit` in `state`.
It returns an iterator designating the first element beyond
any prefix of a valid year input field. In either case, if the
return value equals `last`, the function sets
`ios_base::eofbit` in `state`.

The year input field is a sequence of decimal digits whose
corresponding numeric value must be in the range [1900, 2036).
The stored value is this value minus 1900.
In this [implementation](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_index.html#implementation),
values in the range [69, 136) represent the range of years [1969, 2036).
Values in the range [0, 69) are also permissible, but may represent
either the range of years [1900, 1969) or [2000, 2069),
depending on the specific translation environment.

### `time_get::get_date`

    iter_type get_date(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state, tm *pt) const;Copy to clipboard

The member function returns
`do_get_date(first, last,
iosbase, state, pt)`.

### `time_get::get_month`

    iter_type get_month(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state, tm *pt) const;Copy to clipboard

The member function returns
`do_get_month(first, last,
iosbase, state, pt)`.

### `time_get::get_time`

    iter_type get_time(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state, tm *pt) const;Copy to clipboard

The member function returns
`do_get_time(first, last,
iosbase, state, pt)`.

### `time_get::get_weekday`

    iter_type get_weekday(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state, tm *pt) const;Copy to clipboard

The member function returns
`do_get_weekday(first, last,
iosbase, state, pt)`.

### `time_get::get_year`

    iter_type get_year(iter_type first, iter_type last,
        ios_base& iosbase, ios_base::iostate& state, tm *pt) const;Copy to clipboard

The member function returns
`do_get_year(first, last,
iosbase, state, pt)`.

### `time_get::iter_type`

    typedef InIt iter_type;Copy to clipboard

The type is a synonym for the template parameter `InIt`.

### `time_get::time_get`

    explicit time_get(size_t refs = 0);Copy to clipboard

The constructor initializes its base object with
`locale::facet(refs)`.

## `time_get_byname`

    template<class Elem, class InIt>
        class time_get_byname
            : public time_get<Elem, InIt> {
    public:
        explicit time_get_byname(const char *locname,
            size_t refs = 0);
    protected:
        ~time_get_byname();
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) of type
`time_get<Elem, InIt>`.
Its behavior is determined by the
[named](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20name) locale `locname`.
The constructor initializes its base object with
`time_get<Elem,
InIt>(refs)`.

## `time_put`

    template<class Elem, class OutIt = ostreambuf_iterator<Elem> >
        class time_put
            : public locale::facet {
    public:
        typedef Elem char_type;
        typedef OutIt iter_type;
        explicit time_put(size_t refs = 0);
        iter_type put(iter_type next, ios_base& iosbase,
            char_type fill, const tm *pt, char fmt, char mod = 0) const;
        iter_type put(iter_type next, ios_base& iosbase,
            char_type fill, const tm *pt, const Elem *first, const Elem *last) const;
        static locale::id id;
    protected:
        ~time_put();
        virtual iter_type do_put(iter_type next, ios_base& iosbase,
            char_type fill, const tm *pt, char fmt, char mod = 0) const;
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet), to control conversions
of time values to sequences of type `Elem`.

As with any locale facet, the static object
**`id`** has an initial
stored value of zero. The first attempt to access its stored value
stores a unique positive value in `id`.

### `time_put::char_type`

    typedef Elem char_type;Copy to clipboard

The type is a synonym for the template parameter `Elem`.

### `time_put::do_put`

    virtual iter_type do_put(iter_type next, ios_base& iosbase,
        char_type fill, const tm *pt, char fmt, char mod = 0) const;Copy to clipboard

The virtual protected member function generates
sequential elements beginning at `next` from
time values stored in the object `*pt`, of type
`tm`.
The function returns an iterator designating the next place to
insert an element beyond the generated output.

The output is generated by the same rules used by
`strftime`,
with a last argument of `pt`,
for generating a series of *char* elements into an array.
(Each such *char* element is assumed to map to an equivalent element
of type `Elem` by a simple, one-to-one, mapping.)
If `mod` equals zero, the effective format is
`"%F"`, where `F` is replaced by `fmt`.
Otherwise, the effective format is
`"%MF"`, where `M` is replaced by `mod`.

The parameter `fill` is not used.

### `time_put::put`

    iter_type put(iter_type next, ios_base& iosbase,
        char_type fill, const tm *pt, char fmt, char mod = 0) const;
    iter_type put(iter_type next, ios_base& iosbase,
        char_type fill, const tm *pt, const Elem *first, const Elem *last) const;Copy to clipboard

The first member function returns
`do_put(next,
iosbase, fill, pt, fmt, mod)`. The second member function
copies to `*next++` any element in the interval
`[first, last)` other than a percent (`%`).
For a percent followed by a character `C` in the interval
`[first, last)`, the function instead evaluates
`next = do_put(next, iosbase, fill, pt, C, 0)`
and skips past `C`.
If, however, `C` is a qualifier character from the set
`EOQ#`, followed by a character `C2` in the interval
`[first, last)`, the function instead evaluates
`next = do_put(next, iosbase, fill, pt, C2, C)`
and skips past `C2`.

### `time_put::iter_type`

    typedef InIt iter_type;Copy to clipboard

The type is a synonym for the template parameter `OutIt`.

### `time_put::time_put`

    explicit time_put(size_t refs = 0);Copy to clipboard

The constructor initializes its base object with
`locale::facet(refs)`.

## `time_put_byname`

    template<class Elem, class OutIt>
        class time_put_byname
            : public time_put<Elem, OutIt> {
    public:
        explicit time_put_byname(const char *locname,
            size_t refs = 0);
    protected:
        ~time_put_byname();
        };Copy to clipboard

The template class describes an object that can serve as a
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) of type
`time_put<Elem, OutIt>`.
Its behavior is determined by the
[named](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20name) locale `locname`.
The constructor initializes its base object with
`time_put<Elem,
OutIt>(refs)`.

## `tolower`

    template<class Elem>
        Elem tolower(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
tolower(ch)`.

## `toupper`

    template<class Elem>
        Elem toupper(Elem ch, const locale& loc) const;Copy to clipboard

The template function returns
`use_facet<
ctype<Elem> >(loc).
toupper(ch)`.

## `use_facet`

    template<class Facet>
        const Facet& use_facet(const locale& loc);Copy to clipboard

The template function returns a reference to the
[locale facet](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20facet) of class `Facet`
listed within the
[locale object](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_locale2.html#locale%20object) `loc`.
If no such object is listed, the function throws an object of class
`bad_cast`.

* * *

See also the
**[Table of Contents](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_index.html#Table%20of%20Contents)** and the
**[Index](https://docs.qualcomm.com/doc/80-N3040-23/topic/_cpp_index.html)**.

*[Copyright](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_crit_pjp.html) © 1992-2006by P.J. Plauger. All rights reserved.*

<!--V5.01:1566-->

Last Published: Oct 06, 2026

Previous Topic
 
<locale.h></locale.h> Next Topic

<map></map>