[text]

The type chars_format is a bitmask type ([bitmask.types]) with elements scientific, fixed, and hex.

The types to_chars_result and from_chars_result have the data members and special members specified above.

They have no base classes or members other than those specified.

28.2.2 Primitive numeric output conversion [charconv.to.chars]

All functions named to_chars convert value into a character string by successively filling the range [first, last), where [first, last) is required to be a valid range.

If the member ec of the return value is such that the value is equal to the value of a value-initialized errc, the conversion was successful and the member ptr is the one-past-the-end pointer of the characters written.

Otherwise, the member ec has the value errc::value_too_large, the member ptr has the value last, and the contents of the range [first, last) are unspecified.

The functions that take a floating-point value but not a precision parameter ensure that the string representation consists of the smallest number of characters such that there is at least one digit before the radix point (if present) and parsing the representation using the corresponding from_chars function recovers value exactly.

[Note 1:

This guarantee applies only if to_chars and from_chars are executed on the same implementation.

— end note]

If there are several such representations, the representation with the smallest difference from the floating-point argument value is chosen, resolving any remaining ties using rounding according to round_to_nearest ([round.style]).

The functions taking a chars_format parameter determine the conversion specifier for printf as follows: The conversion specifier is f if fmt is chars_format::fixed, e if fmt is chars_format::scientific, a (without leading "0x" in the result) if fmt is chars_format::hex, and g if fmt is chars_format::general.

🔗

constexpr to_chars_result to_chars(char* first, char* last, integer-type value, int base = 10);

Effects: The value of value is converted to a string of digits in the given base (with no redundant leading zeroes).

Digits in the range 10..35 (inclusive) are represented as lowercase characters a..z.

If value is less than zero, the representation starts with '-'.

Throws: Nothing.

🔗

to_chars_result to_chars(char* first, char* last, floating-point-type value);

Effects: value is converted to a string in the style of printf in the "C" locale.

The conversion specifier is f or e, chosen according to the requirement for a shortest representation (see above); a tie is resolved in favor of f.

Throws: Nothing.

🔗

to_chars_result to_chars(char* first, char* last, floating-point-type value, chars_format fmt);

Preconditions: fmt has the value of one of the enumerators of chars_format.

Effects: value is converted to a string in the style of printf in the "C" locale.

Throws: Nothing.

🔗

to_chars_result to_chars(char* first, char* last, floating-point-type value,
                         chars_format fmt, int precision);

Preconditions: fmt has the value of one of the enumerators of chars_format.

Effects: value is converted to a string in the style of printf in the "C" locale with the given precision.

All functions named from_chars analyze the string [first, last) for a pattern, where [first, last) is required to be a valid range.

If no characters match the pattern, value is unmodified, the member ptr of the return value is first and the member ec is equal to errc::invalid_argument.

[Note 1:

If the pattern allows for an optional sign, but the string has no digit characters following the sign, no characters match the pattern.

— end note]

Otherwise, the characters matching the pattern are interpreted as a representation of a value of the type of value.

The member ptr of the return value points to the first character not matching the pattern, or has the value last if all characters match.

If the parsed value is not in the range representable by the type of value, value is unmodified and the member ec of the return value is equal to errc::result_out_of_range.

Otherwise, value is set to the parsed value, after rounding according to round_to_nearest ([round.style]), and the member ec is value-initialized.

🔗

constexpr from_chars_result from_chars(const char* first, const char* last,
                                       integer-type& value, int base = 10);

Effects: The pattern is the expected form of the subject sequence in the "C" locale for the given nonzero base, as described for strtol, except that no "0b" or "0B" prefix shall appear if the value of base is 2, no "0x" or "0X" prefix shall appear if the value of base is 16, and except that '-' is the only sign that may appear, and only if value has a signed type.

Throws: Nothing.

🔗

from_chars_result from_chars(const char* first, const char* last, floating-point-type& value,
                             chars_format fmt = chars_format::general);

Preconditions: fmt has the value of one of the enumerators of chars_format.

Effects: The pattern is the expected form of the subject sequence in the "C" locale, as described for strtod, except that

(6.1)
the sign '+' may only appear in the exponent part;
(6.2)
if fmt has chars_format::scientific set but not chars_format::fixed, the otherwise optional exponent part shall appear;
(6.3)
if fmt has chars_format::fixed set but not chars_format::scientific, the optional exponent part shall not appear; and
(6.4)
if fmt is chars_format::hex, the prefix "0x" or "0X" is assumed.
[Example 1:
The string 0x123 is parsed to have the value 0 with remaining characters x123.
— end example]

In any case, the resulting value is one of at most two floating-point values closest to the value of the string matching the pattern.

Subclause [localization] describes components that C++ programs may use to encapsulate (and therefore be more portable when confronting) cultural differences.

The locale facility includes internationalization support for character classification and string collation, numeric, monetary, and date/time formatting and parsing, and message retrieval.

The following subclauses describe components for locales themselves, the standard facets, and facilities from the C library, as summarized in Table 90 .

Table 90 — Localization library summary [tab:localization.summary]

🔗	Subclause	Header
🔗 [locales]	Locales	<locale>
🔗 [locale.categories]	Standard locale categories
🔗 [c.locales]	C library locales	<clocale>
🔗

28.3.2 Header <locale> synopsis [locale.syn]

🔗

namespace std { / [locale], locale class locale; template<class Facet> const Facet& use_facet(const locale&); template<class Facet> bool has_facet(const locale&) noexcept; / [locale.convenience], convenience interfaces template<class charT> bool isspace (charT c, const locale& loc); template<class charT> bool isprint (charT c, const locale& loc); template<class charT> bool iscntrl (charT c, const locale& loc); template<class charT> bool isupper (charT c, const locale& loc); template<class charT> bool islower (charT c, const locale& loc); template<class charT> bool isalpha (charT c, const locale& loc); template<class charT> bool isdigit (charT c, const locale& loc); template<class charT> bool ispunct (charT c, const locale& loc); template<class charT> bool isxdigit(charT c, const locale& loc); template<class charT> bool isalnum (charT c, const locale& loc); template<class charT> bool isgraph (charT c, const locale& loc); template<class charT> bool isblank (charT c, const locale& loc); template<class charT> charT toupper(charT c, const locale& loc); template<class charT> charT tolower(charT c, const locale& loc); / [category.ctype], ctype class ctype_base; template<class charT> class ctype; template<> class ctype<char>; / specialization template<class charT> class ctype_byname; class codecvt_base; template<class internT, class externT, class stateT> class codecvt; template<class internT, class externT, class stateT> class codecvt_byname; / [category.numeric], numeric template<class charT, class InputIterator = istreambuf_iterator<charT>> class num_get; template<class charT, class OutputIterator = ostreambuf_iterator<charT>> class num_put; template<class charT> class numpunct; template<class charT> class numpunct_byname; / [category.collate], collation template<class charT> class collate; template<class charT> class collate_byname; / [category.time], date and time class time_base; template<class charT, class InputIterator = istreambuf_iterator<charT>> class time_get; template<class charT, class InputIterator = istreambuf_iterator<charT>> class time_get_byname; template<class charT, class OutputIterator = ostreambuf_iterator<charT>> class time_put; template<class charT, class OutputIterator = ostreambuf_iterator<charT>> class time_put_byname; / [category.monetary], money class money_base; template<class charT, class InputIterator = istreambuf_iterator<charT>> class money_get; template<class charT, class OutputIterator = ostreambuf_iterator<charT>> class money_put; template<class charT, bool Intl = false> class moneypunct; template<class charT, bool Intl = false> class moneypunct_byname; / [category.messages], message retrieval class messages_base; template<class charT> class messages; template<class charT> class messages_byname; }

The header <locale> defines classes and declares functions that encapsulate and manipulate the information peculiar to a locale.205

205)205)

In this subclause, the type name tm is an incomplete type that is defined in <ctime>.

28.3.3 Locales [locales]

28.3.3.1 Class locale [locale]

28.3.3.1.1 General [locale.general]

namespace std { class locale { public: / [locale.types], types / [locale.facet], class locale::facet class facet; / [locale.id], class locale::id class id; / [locale.category], type locale::category using category = int; static const category / values assigned here are for exposition only none = 0, collate = 0x010, ctype = 0x020, monetary = 0x040, numeric = 0x080, time = 0x100, messages = 0x200, all = collate | ctype | monetary | numeric | time | messages; / [locale.cons], construct/copy/destroy locale() noexcept; locale(const locale& other) noexcept; explicit locale(const char* std_name); explicit locale(const string& std_name); locale(const locale& other, const char* std_name, category); locale(const locale& other, const string& std_name, category); template<class Facet> locale(const locale& other, Facet* f); locale(const locale& other, const locale& one, category); ~locale(); / not virtual const locale& operator=(const locale& other) noexcept; / [locale.members], locale operations template<class Facet> locale combine(const locale& other) const; string name() const; text_encoding encoding() const; bool operator=(const locale& other) const; template<class charT, class traits, class Allocator> bool operator()(const basic_string<charT, traits, Allocator>& s1, const basic_string<charT, traits, Allocator>& s2) const; / [locale.statics], global locale objects static locale global(const locale&); static const locale& classic(); }; }

Class locale implements a type-safe polymorphic set of facets, indexed by facet type.

In other words, a facet has a dual role: in one sense, it's just a class interface; at the same time, it's an index into a locale's set of facets.

Access to the facets of a locale is via two function templates, use_facet<> and has_facet<>.

[Example 1:

An iostream operator< can be implemented as:206

template<class charT, class traits> basic_ostream<charT, traits>& operator< (basic_ostream<charT, traits>& s, Date d) { typename basic_ostream<charT, traits>::sentry cerberos(s); if (cerberos) { tm tmbuf; d.extract(tmbuf); bool failed = use_facet<time_put<charT, ostreambuf_iterator<charT, traits>>( s.getloc().put(s, s, s.fill(), &tmbuf, 'x').failed(); if (failed) s.setstate(s.badbit); / can throw } return s; } — end example]

In the call to use_facet<Facet>(loc), the type argument chooses a facet, making available all members of the named type.

If Facet is not present in a locale, it throws the standard exception bad_cast.

A C++ program can check if a locale implements a particular facet with the function template has_facet<Facet>().

User-defined facets may be installed in a locale, and used identically as may standard facets.

[Note 1:

All locale semantics are accessed via use_facet<> and has_facet<>, except that:

(5.1)
A member operator template operator()(const basic_string<C, T, A>&, const basic_string<C, T, A>&) is provided so that a locale can be used as a predicate argument to the standard collections, to collate strings.
(5.2)
Convenient global interfaces are provided for traditional ctype functions such as isdigit() and isspace(), so that given a locale object loc a C++ program can call isspace(c, loc).
(This eases upgrading existing extractors ([istream.formatted]).)

— end note]

Once a facet reference is obtained from a locale object by calling use_facet<>, that reference remains usable, and the results from member functions of it may be cached and re-used, as long as some locale object refers to that facet.

In successive calls to a locale facet member function on a facet object installed in the same locale, the returned result shall be identical.

A locale constructed from a name string (such as "POSIX"), or from parts of two named locales, has a name; all others do not.

Named locales may be compared for equality; an unnamed locale is equal only to (copies of) itself.

For an unnamed locale, locale::name() returns the string "*".

Whether there is one global locale object for the entire program or one global locale object per thread is implementation-defined.

Implementations should provide one global locale object per thread.

If there is a single global locale object for the entire program, implementations are not required to avoid data races on it ([res.on.data.races]).

206)206)

Note that in the call to put, the stream is implicitly converted to an ostreambuf_iterator<charT, traits>.

28.3.3.1.2 Types [locale.types]

28.3.3.1.2.1 Type locale::category [locale.category]

🔗

using category = int;

Valid category values include the locale member bitmask elements collate, ctype, monetary, numeric, time, and messages, each of which represents a single locale category.

In addition, locale member bitmask constant none is defined as zero and represents no category.

Further, the expression (X | Y), where X and Y each represent a single category, represents the union of the two categories.

locale member functions expecting a category argument require one of the category values defined above, or the union of two or more such values.

Such a category value identifies a set of locale categories.

Each locale category, in turn, identifies a set of locale facets, including at least those shown in Table 91 .

For any locale loc either constructed, or returned by locale::classic(), and any facet Facet shown in Table 91, has_facet<Facet>(loc) is true.

Each locale member function which takes a locale::category argument operates on the corresponding set of facets.

An implementation is required to provide those specializations for facet templates identified as members of a category, and for those shown in Table 92 .

Table 92 — Required specializations [tab:locale.spec]

🔗 Category	Includes facets
🔗 collate	collate_byname<char>, collate_byname<wchar_t>
🔗 ctype	ctype_byname<char>, ctype_byname<wchar_t>
🔗	codecvt_byname<char, char, mbstate_t>
🔗	codecvt_byname<wchar_t, char, mbstate_t>
🔗 monetary	moneypunct_byname<char, International>
🔗	moneypunct_byname<wchar_t, International>
🔗	money_get<C, InputIterator>
🔗	money_put<C, OutputIterator>
🔗 numeric	numpunct_byname<char>, numpunct_byname<wchar_t>
🔗	num_get<C, InputIterator>, num_put<C, OutputIterator>
🔗 time	time_get<char, InputIterator>
🔗	time_get_byname<char, InputIterator>
🔗	time_get<wchar_t, InputIterator>
🔗	time_get_byname<wchar_t, InputIterator>
🔗	time_put<char, OutputIterator>
🔗	time_put_byname<char, OutputIterator>
🔗	time_put<wchar_t, OutputIterator>
🔗	time_put_byname<wchar_t, OutputIterator>
🔗 messages	messages_byname<char>, messages_byname<wchar_t>

The provided implementation of members of facets num_get<charT> and num_put<charT> calls use_facet<F>(l) only for facet F of types numpunct<charT> and ctype<charT>, and for locale l the value obtained by calling member getloc() on the ios_base& argument to these functions.

In declarations of facets, a template parameter with name InputIterator or OutputIterator indicates the set of all possible specializations on parameters that meet the Cpp17InputIterator requirements or Cpp17OutputIterator requirements, respectively ([iterator.requirements]).

A template parameter with name C represents the set of types containing char, wchar_t, and any other implementation-defined character container types ([defns.character.container]) that meet the requirements for a character on which any of the iostream components can be instantiated.

A template parameter with name International represents the set of all possible specializations on a bool parameter.

207)207)

This is a complete list of requirements; there are no other requirements.

Thus, a facet class need not have a public copy constructor, assignment, default constructor, destructor, etc.

28.3.3.1.2.3 Class locale::id [locale.id]

🔗

namespace std { class locale::id { public: id(); void operator=(const id&) = delete; id(const id&) = delete; }; }

The class locale::id provides identification of a locale facet interface, used as an index for lookup and to encapsulate initialization.

[Note 1:

Because facets are used by iostreams, potentially while static constructors are running, their initialization cannot depend on programmed static initialization.

One initialization strategy is for locale to initialize each facet's id member the first time an instance of the facet is installed into a locale.

This depends only on static storage being zero before constructors run ([basic.start.static]).

— end note]

28.3.3.1.3 Constructors and destructor [locale.cons]

🔗

locale() noexcept;

Effects: Constructs a copy of the argument last passed to locale::global(locale&), if it has been called; else, the resulting facets have virtual function semantics identical to those of locale::classic().

[Note 1:

This constructor yields a copy of the current global locale.

It is commonly used as a default argument for function parameters of type const locale&.

— end note]

🔗

explicit locale(const char* std_name);

Effects: Constructs a locale using standard C locale names, e.g., "POSIX".

The resulting locale implements semantics defined to be associated with that name.

Remarks: The set of valid string argument values is "C", "", and any implementation-defined values.

🔗

explicit locale(const string& std_name);

Effects: Equivalent to locale(std_name.c_str().

🔗

locale(const locale& other, const char* std_name, category cats);

Effects: Constructs a locale as a copy of other except for the facets identified by the category argument, which instead implement the same semantics as locale(std_name).

Remarks: The locale has a name if and only if other has a name.

🔗

locale(const locale& other, const string& std_name, category cats);

Effects: Equivalent to locale(other, std_name.c_str(), cats).

🔗

template<class Facet> locale(const locale& other, Facet* f);

Effects: Constructs a locale incorporating all facets from the first argument except that of type Facet, and installs the second argument as the remaining facet.

If f is null, the resulting object is a copy of other.

Remarks: If f is null, the resulting locale has the same name as other.

Otherwise, the resulting locale has no name.

🔗

locale(const locale& other, const locale& one, category cats);

Effects: Constructs a locale incorporating all facets from the first argument except those that implement cats, which are instead incorporated from the second argument.

Remarks: If cats is equal to locale::none, the resulting locale has a name if and only if the first argument has a name.

Otherwise, the resulting locale has a name if and only if the first two arguments both have names.

🔗

const locale& operator=(const locale& other) noexcept;

Returns: *this.

28.3.3.1.4 Members [locale.members]

🔗

template<class Facet> locale combine(const locale& other) const;

Effects: Constructs a locale incorporating all facets from *this except for that one facet of other that is identified by Facet.

Remarks: The resulting locale has no name.

🔗

string name() const;

Returns: The name of *this, if it has one; otherwise, the string "*".

🔗

text_encoding encoding() const;

Returns: A text_encoding object representing the implementation-defined encoding scheme associated with the locale *this.

28.3.3.1.5 Operators [locale.operators]

🔗

bool operator=(const locale& other) const;

Returns: true if both arguments are the same locale, or one is a copy of the other, or each has a name and the names are identical; false otherwise.

🔗

template<class charT, class traits, class Allocator>
  bool operator()(const basic_string<charT, traits, Allocator>& s1,
                  const basic_string<charT, traits, Allocator>& s2) const;

Returns: use_facet<std::collate<charT>>(*this).compare(s1.data(), s1.data() + s1.size(), s2.data(), s2.data() + s2.size() < 0

Remarks: This member operator template (and therefore locale itself) meets the requirements for a comparator predicate template argument ([algorithms]) applied to strings.

[Example 1:

A vector of strings v can be collated according to collation rules in locale loc simply by ([alg.sort], [vector]):

std::sort(v.begin(), v.end(), loc); — end example]

28.3.3.1.6 Static members [locale.statics]

🔗

static locale global(const locale& loc);

Effects: Sets the global locale to its argument.

Causes future calls to the constructor locale() to return a copy of the argument.

If the argument has a name, does setlocale(LC_ALL, loc.name().c_str(); otherwise, the effect on the C locale, if any, is implementation-defined.

Remarks: No library function other than locale::global() affects the value returned by locale().

[Note 1:

See [c.locales] for data race considerations when setlocale is invoked.

— end note]

🔗

static const locale& classic();

Returns: A locale that implements the classic "C" locale semantics, equivalent to the value locale("C").

Remarks: This locale, its facets, and their member functions, do not change with time.

28.3.3.2 locale globals [locale.global.templates]

🔗

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

Mandates: Facet is a facet class whose definition contains the public static member id as defined in [locale.facet].

Remarks: The reference returned remains valid at least as long as any copy of loc exists.

🔗

template<class Facet> bool has_facet(const locale& loc) noexcept;

Returns: true if the facet requested is present in loc; otherwise false.

28.3.3.3 Convenience interfaces [locale.convenience]

28.3.3.3.1 Character classification [classification]

🔗

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

Each of these functions isF returns the result of the expression: use_facet<ctype<charT>>(loc).is(ctype_base::F, c) where F is the ctype_base::mask value corresponding to that function ([category.ctype]).208

208)208)

When used in a loop, it is faster to cache the ctype<> facet and use it directly, or use the vector form of ctype<>::is.

28.3.3.3.2 Character conversions [conversions.character]

🔗

template<class charT> charT toupper(charT c, const locale& loc);

Returns: use_facet<ctype<charT>>(loc).toupper(c).

🔗

template<class charT> charT tolower(charT c, const locale& loc);

Each of the standard categories includes a family of facets.

Some of these implement formatting or parsing of a datum, for use by standard or users' iostream operators << and >>, as members put() and get(), respectively.

Each such member function takes an ios_base& argument whose members flags(), precision(), and width(), specify the format of the corresponding datum ([ios.base]).

Those functions which need to use other facets call its member getloc() to retrieve the locale imbued there.

Formatting facets use the character argument fill to fill out the specified width where necessary.

The put() members make no provision for error reporting.

(Any failures of the OutputIterator argument can be extracted from the returned iterator.)

The get() members take an ios_base::iostate& argument whose value they ignore, but set to ios_base::failbit in case of a parse error.

Within [locale.categories] it is unspecified whether one virtual function calls another virtual function.

28.3.4.2 The ctype category [category.ctype]

28.3.4.2.1 General [category.ctype.general]

🔗

namespace std { class ctype_base { public: using mask = see below; / numeric values are for exposition only. static constexpr mask space = 1 << 0; static constexpr mask print = 1 << 1; static constexpr mask cntrl = 1 << 2; static constexpr mask upper = 1 << 3; static constexpr mask lower = 1 << 4; static constexpr mask alpha = 1 << 5; static constexpr mask digit = 1 << 6; static constexpr mask punct = 1 << 7; static constexpr mask xdigit = 1 << 8; static constexpr mask blank = 1 << 9; static constexpr mask alnum = alpha | digit; static constexpr mask graph = alnum | punct; }; }

The type mask is a bitmask type ([bitmask.types]).

28.3.4.2.2 Class template ctype [locale.ctype]

28.3.4.2.2.1 General [locale.ctype.general]

🔗

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

Class ctype encapsulates the C library <cctype> features.

istream members are required to use ctype<> for character classing during input parsing.

The specializations required in Table 91 ([locale.category]), namely ctype<char> and ctype<wchar_t>, implement character classing appropriate to the implementation's native character set.

28.3.4.2.2.2 ctype members [locale.ctype.members]

🔗

bool         is(mask m, charT c) const;
const charT* is(const charT* low, const charT* high, mask* vec) const;

Returns: do_is(m, c) or do_is(low, high, vec).

🔗

const charT* scan_is(mask m, const charT* low, const charT* high) const;

Returns: do_scan_is(m, low, high).

🔗

const charT* scan_not(mask m, const charT* low, const charT* high) const;

Returns: do_scan_not(m, low, high).

🔗

charT        toupper(charT c) const;
const charT* toupper(charT* low, const charT* high) const;

Returns: do_toupper(c) or do_toupper(low, high).

🔗

charT        tolower(charT c) const;
const charT* tolower(charT* low, const charT* high) const;

Returns: do_tolower(c) or do_tolower(low, high).

🔗

charT       widen(char c) const;
const char* widen(const char* low, const char* high, charT* to) const;

Returns: do_widen(c) or do_widen(low, high, to).

🔗

char         narrow(charT c, char dfault) const;
const charT* narrow(const charT* low, const charT* high, char dfault, char* to) const;

Returns: do_narrow(c, dfault) or do_narrow(low, high, dfault, to).

28.3.4.2.2.3 ctype virtual functions [locale.ctype.virtuals]

🔗

bool         do_is(mask m, charT c) const;
const charT* do_is(const charT* low, const charT* high, mask* vec) const;

Effects: Classifies a character or sequence of characters.

For each argument character, identifies a value M of type ctype_base::mask.

The second form identifies a value M of type ctype_base::mask for each *p where (low <= p && p < high), and places it into vec[p - low].

Returns: The first form returns the result of the expression (M & m) != 0; i.e., true if the character has the characteristics specified.

The second form returns high.

🔗

const charT* do_scan_is(mask m, const charT* low, const charT* high) const;

Returns: The smallest pointer p in the range [low, high) such that is(m, *p) would return true; otherwise, returns high.

🔗

const charT* do_scan_not(mask m, const charT* low, const charT* high) const;

Effects: Locates a character in a buffer that fails to conform to a classification m.

Returns: The smallest pointer p, if any, in the range [low, high) such that is(m, *p) would return false; otherwise, returns high.

🔗

charT        do_toupper(charT c) const;
const charT* do_toupper(charT* low, const charT* high) const;

Effects: Converts a character or characters to upper case.

The second form replaces each character *p in the range [low, high) for which a corresponding upper-case character exists, with that character.

Returns: The first form returns the corresponding upper-case character if it is known to exist, or its argument if not.

The second form returns high.

🔗

charT        do_tolower(charT c) const;
const charT* do_tolower(charT* low, const charT* high) const;

Effects: Converts a character or characters to lower case.

The second form replaces each character *p in the range [low, high) and for which a corresponding lower-case character exists, with that character.

Returns: The first form returns the corresponding lower-case character if it is known to exist, or its argument if not.

The second form returns high.

🔗

charT        do_widen(char c) const;
const char*  do_widen(const char* low, const char* high, charT* dest) const;

Effects: Applies the simplest reasonable transformation from a char value or sequence of char values to the corresponding charT value or values.209

The only characters for which unique transformations are required are those in the basic character set ([lex.charset]).

For any named ctype category with a ctype<char> facet ctc and valid ctype_base::mask value M, (ctc.is(M, c) || !is(M, do_widen(c)) ) is true.210

The second form transforms each character *p in the range [low, high), placing the result in dest[p - low].

Returns: The first form returns the transformed value.

The second form returns high.

🔗

char         do_narrow(charT c, char dfault) const;
const charT* do_narrow(const charT* low, const charT* high, char dfault, char* dest) const;

Effects: Applies the simplest reasonable transformation from a charT value or sequence of charT values to the corresponding char value or values.

For any character c in the basic character set ([lex.charset]) the transformation is such that do_widen(do_narrow(c, 0) == c

For any named ctype category with a ctype<char> facet ctc however, and ctype_base::mask value M, (is(M, c) || !ctc.is(M, do_narrow(c, dfault)) ) is true (unless do_narrow returns dfault).

In addition, for any digit character c, the expression (do_narrow(c, dfault) - '0') evaluates to the digit value of the character.

The second form transforms each character *p in the range [low, high), placing the result (or dfault if no simple transformation is readily available) in dest[p - low].

Returns: The first form returns the transformed value; or dfault if no mapping is readily available.

The second form returns high.

209)209)

The parameter c of do_widen is intended to accept values derived from character-literals for conversion to the locale's encoding.

210)210)

In other words, the transformed character is not a member of any character classification that c is not also a member of.

28.3.4.2.3 Class template ctype_byname [locale.ctype.byname]

🔗

namespace std { template<class charT> class ctype_byname : public ctype<charT> { public: using mask = ctype<charT>::mask; explicit ctype_byname(const char*, size_t refs = 0); explicit ctype_byname(const string&, size_t refs = 0); protected: ~ctype_byname(); }; }

🔗

namespace std { template<> class ctype<char> : public locale::facet, public ctype_base { public: using char_type = char; explicit ctype(const mask* tab = nullptr, bool del = false, size_t refs = 0); bool is(mask m, char c) const; const char* is(const char* low, const char* high, mask* vec) const; const char* scan_is (mask m, const char* low, const char* high) const; const char* scan_not(mask m, const char* low, const char* high) const; char toupper(char c) const; const char* toupper(char* low, const char* high) const; char tolower(char c) const; const char* tolower(char* low, const char* high) const; char widen(char c) const; const char* widen(const char* low, const char* high, char* to) const; char narrow(char c, char dfault) const; const char* narrow(const char* low, const char* high, char dfault, char* to) const; static locale::id id; static const size_t table_size = implementation-defined; const mask* table() const noexcept; static const mask* classic_table() noexcept; protected: ~ctype(); virtual char do_toupper(char c) const; virtual const char* do_toupper(char* low, const char* high) const; virtual char do_tolower(char c) const; virtual const char* do_tolower(char* low, const char* high) const; virtual char do_widen(char c) const; virtual const char* do_widen(const char* low, const char* high, char* to) const; virtual char do_narrow(char c, char dfault) const; virtual const char* do_narrow(const char* low, const char* high, char dfault, char* to) const; }; }

211)211)

Only the char (not unsigned char and signed char) form is provided.

The specialization is specified in the standard, and not left as an implementation detail, because it affects the derivation interface for ctype<char>.

🔗

~ctype();

🔗

explicit ctype(const mask* tbl = nullptr, bool del = false, size_t refs = 0);

🔗

bool        is(mask m, char c) const;
const char* is(const char* low, const char* high, mask* vec) const;

🔗

const char* scan_is(mask m, const char* low, const char* high) const;

🔗

const char* scan_not(mask m, const char* low, const char* high) const;

🔗

char        toupper(char c) const;
const char* toupper(char* low, const char* high) const;

🔗

char        tolower(char c) const;
const char* tolower(char* low, const char* high) const;

🔗

char  widen(char c) const;
const char* widen(const char* low, const char* high, char* to) const;

🔗

char        narrow(char c, char dfault) const;
const char* narrow(const char* low, const char* high, char dfault, char* to) const;

🔗

const mask* table() const noexcept;

🔗

static const mask* classic_table() noexcept;

🔗

char do_toupper(char) const; const char* do_toupper(char* low, const char* high) const; char do_tolower(char) const; const char* do_tolower(char* low, const char* high) const; virtual char do_widen(char c) const; virtual const char* do_widen(const char* low, const char* high, char* to) const; virtual char do_narrow(char c, char dfault) const; virtual const char* do_narrow(const char* low, const char* high, char dfault, char* to) const;

28.3.4.2.5 Class template codecvt [locale.codecvt]

28.3.4.2.5.1 General [locale.codecvt.general]

🔗

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

The class codecvt<internT, externT, stateT> is for use when converting from one character encoding to another, such as from wide characters to multibyte characters or between wide character encodings such as UTF-32 and EUC.

The stateT argument selects the pair of character encodings being mapped between.

The specializations required in Table 91 ([locale.category]) convert the implementation-defined native character set.

codecvt<char, char, mbstate_t> implements a degenerate conversion; it does not convert at all.

codecvt<wchar_t, char, mbstate_t> converts between the native character sets for ordinary and wide characters.

Specializations on mbstate_t perform conversion between encodings known to the library implementer.

Other encodings can be converted by specializing on a program-defined stateT type.

Objects of type stateT can contain any state that is useful to communicate to or from the specialized do_in or do_out members.

28.3.4.2.5.2 Members [locale.codecvt.members]

🔗

result out(
  stateT& state,
  const internT* from, const internT* from_end, const internT*& from_next,
  externT* to, externT* to_end, externT*& to_next) const;

Returns: do_out(state, from, from_end, from_next, to, to_end, to_next).

🔗

result unshift(stateT& state, externT* to, externT* to_end, externT*& to_next) const;

Returns: do_unshift(state, to, to_end, to_next).

🔗

result in(
  stateT& state,
  const externT* from, const externT* from_end, const externT*& from_next,
  internT* to, internT* to_end, internT*& to_next) const;

Returns: do_in(state, from, from_end, from_next, to, to_end, to_next).

🔗

int encoding() const noexcept;

Returns: do_encoding().

🔗

bool always_noconv() const noexcept;

Returns: do_always_noconv().

🔗

int length(stateT& state, const externT* from, const externT* from_end, size_t max) const;

Returns: do_length(state, from, from_end, max).

🔗

int max_length() const noexcept;

Returns: do_max_length().

28.3.4.2.5.3 Virtual functions [locale.codecvt.virtuals]

🔗

result do_out(
  stateT& state,
  const internT* from, const internT* from_end, const internT*& from_next,
  externT* to, externT* to_end, externT*& to_next) const;

result do_in(
  stateT& state,
  const externT* from, const externT* from_end, const externT*& from_next,
  internT* to, internT* to_end, internT*& to_next) const;

Preconditions: (from <= from_end && to <= to_end) is well-defined and true; state is initialized, if at the beginning of a sequence, or else is equal to the result of converting the preceding characters in the sequence.

Effects: Translates characters in the source range [from, from_end), placing the results in sequential positions starting at destination to.

Converts no more than (from_end - from) source elements, and stores no more than (to_end - to) destination elements.

Stops if it encounters a character it cannot convert.

It always leaves the from_next and to_next pointers pointing one beyond the last element successfully converted.

If it returns noconv, internT and externT are the same type, and the converted sequence is identical to the input sequence [from, from_next), to_next is set equal to to, the value of state is unchanged, and there are no changes to the values in [to, to_end).

A codecvt facet that is used by basic_filebuf ([file.streams]) shall have the property that if do_out(state, from, from_end, from_next, to, to_end, to_next) would return ok, where from != from_end, then do_out(state, from, from + 1, from_next, to, to_end, to_next) shall also return ok, and that if do_in(state, from, from_end, from_next, to, to_end, to_next) would return ok, where to != to_end, then do_in(state, from, from_end, from_next, to, to + 1, to_next) shall also return ok.212

[Note 1:

As a result of operations on state, it can return ok or partial and set from_next == from and to_next != to.

— end note]

Returns: An enumeration value, as summarized in Table 93 .

Table 93 — do_in/do_out result values [tab:locale.codecvt.inout]

🔗 Value	Meaning
🔗 ok	completed the conversion
🔗 partial	not all source characters converted
🔗 error	encountered a character in [from, from_end) that cannot be converted
🔗 noconv	internT and externT are the same type, and input sequence is identical to converted sequence

A return value of partial, if (from_next == from_end), indicates that either the destination sequence has not absorbed all the available destination elements, or that additional source elements are needed before another destination element can be produced.

Remarks: Its operations on state are unspecified.

[Note 2:

This argument can be used, for example, to maintain shift state, to specify conversion options (such as count only), or to identify a cache of seek offsets.

— end note]

🔗

result do_unshift(stateT& state, externT* to, externT* to_end, externT*& to_next) const;

Preconditions: (to <= to_end) is well-defined and true; state is initialized, if at the beginning of a sequence, or else is equal to the result of converting the preceding characters in the sequence.

Effects: Places characters starting at to that should be appended to terminate a sequence when the current stateT is given by state.213

Stores no more than (to_end - to) destination elements, and leaves the to_next pointer pointing one beyond the last element successfully stored.

Returns: An enumeration value, as summarized in Table 94 .

Table 94 — do_unshift result values [tab:locale.codecvt.unshift]

🔗 Value	Meaning
🔗 ok	completed the sequence
🔗 partial	space for more than to_end - to destination elements was needed to terminate a sequence given the value of state
🔗 error	an unspecified error has occurred
🔗 noconv	no termination is needed for this state_type

🔗

int do_encoding() const noexcept;

Returns: -1 if the encoding of the externT sequence is state-dependent; else the constant number of externT characters needed to produce an internal character; or 0 if this number is not a constant.214

🔗

bool do_always_noconv() const noexcept;

Returns: true if do_in() and do_out() return noconv for all valid argument values.

codecvt<char, char, mbstate_t> returns true.

🔗

int do_length(stateT& state, const externT* from, const externT* from_end, size_t max) const;

Preconditions: (from <= from_end) is well-defined and true; state is initialized, if at the beginning of a sequence, or else is equal to the result of converting the preceding characters in the sequence.

Effects: The effect on the state argument is as if it called do_in(state, from, from_end, from, to, to + max, to) for to pointing to a buffer of at least max elements.

Returns: (from_next - from) where from_next is the largest value in the range [from, from_end] such that the sequence of values in the range [from, from_next) represents max or fewer valid complete characters of type internT.

The specialization codecvt<char, char, mbstate_t>, returns the lesser of max and (from_end - from).

🔗

int do_max_length() const noexcept;

Returns: The maximum value that do_length(state, from, from_end, 1) can return for any valid range [from, from_end) and stateT value state.

The specialization codecvt<char, char, mbstate_t>::do_max_length() returns 1.

212)212)

Informally, this means that basic_filebuf assumes that the mappings from internal to external characters is 1 to N: that a codecvt facet that is used by basic_filebuf can translate characters one internal character at a time.

213)213)

Typically these will be characters to return the state to stateT().

214)214)

If encoding() yields -1, then more than max_length() externT elements can be consumed when producing a single internT character, and additional externT elements can appear at the end of a sequence after those that yield the final internT character.

28.3.4.2.6 Class template codecvt_byname [locale.codecvt.byname]

🔗

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

28.3.4.3 The numeric category [category.numeric]

28.3.4.3.1 General [category.numeric.general]

The classes num_get<> and num_put<> handle numeric formatting and parsing.

Virtual functions are provided for several numeric types.

Implementations may (but are not required to) delegate extraction of smaller types to extractors for larger types.215

All specifications of member functions for num_put and num_get in the subclauses of [category.numeric] only apply to the specializations required in Tables 91 and 92 ([locale.category]), namely num_get<char>, num_get<wchar_t>, num_get<C, InputIterator>, num_put<char>, num_put<wchar_t>, and num_put<C, OutputIterator>.

These specializations refer to the ios_base& argument for formatting specifications ([locale.categories]), and to its imbued locale for the numpunct<> facet to identify all numeric punctuation preferences, and also for the ctype<> facet to perform character classification.

Extractor and inserter members of the standard iostreams use num_get<> and num_put<> member functions for formatting and parsing numeric values ([istream.formatted.reqmts], [ostream.formatted.reqmts]).

215)215)

Parsing "-1" correctly into, e.g., an unsigned short requires that the corresponding member get() at least extract the sign before delegating.

28.3.4.3.2 Class template num_get [locale.num.get]

28.3.4.3.2.1 General [locale.num.get.general]

🔗

namespace std { template<class charT, class InputIterator = istreambuf_iterator<charT>> class num_get : public locale::facet { public: using char_type = charT; using iter_type = InputIterator; explicit num_get(size_t refs = 0); iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, bool& v) const; iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, long& v) const; iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, long long& v) const; iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, unsigned short& v) const; iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, unsigned int& v) const; iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, unsigned long& v) const; iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, unsigned long& v) const; iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, float& v) const; iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, double& v) const; iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, long double& v) const; iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, void*& v) const; static locale::id id; protected: ~num_get(); virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, bool& v) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, long& v) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, long long& v) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, unsigned short& v) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, unsigned int& v) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, unsigned long& v) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, unsigned long& v) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, float& v) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, double& v) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, long double& v) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, void*& v) const; }; }

The facet num_get is used to parse numeric values from an input sequence such as an istream.

🔗

iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, bool& val) const;
iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, long& val) const;
iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, long long& val) const;
iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, unsigned short& val) const;
iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, unsigned int& val) const;
iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, unsigned long& val) const;
iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, unsigned long& val) const;
iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, float& val) const;
iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, double& val) const;
iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, long double& val) const;
iter_type get(iter_type in, iter_type end, ios_base& str,
              ios_base::iostate& err, void*& val) const;

🔗

iter_type do_get(iter_type in, iter_type end, ios_base& str,
                 ios_base::iostate& err, long& val) const;
iter_type do_get(iter_type in, iter_type end, ios_base& str,
                 ios_base::iostate& err, long long& val) const;
iter_type do_get(iter_type in, iter_type end, ios_base& str,
                 ios_base::iostate& err, unsigned short& val) const;
iter_type do_get(iter_type in, iter_type end, ios_base& str,
                 ios_base::iostate& err, unsigned int& val) const;
iter_type do_get(iter_type in, iter_type end, ios_base& str,
                 ios_base::iostate& err, unsigned long& val) const;
iter_type do_get(iter_type in, iter_type end, ios_base& str,
                 ios_base::iostate& err, unsigned long& val) const;
iter_type do_get(iter_type in, iter_type end, ios_base& str,
                 ios_base::iostate& err, float& val) const;
iter_type do_get(iter_type in, iter_type end, ios_base& str,
                 ios_base::iostate& err, double& val) const;
iter_type do_get(iter_type in, iter_type end, ios_base& str,
                 ios_base::iostate& err, long double& val) const;
iter_type do_get(iter_type in, iter_type end, ios_base& str,
                 ios_base::iostate& err, void*& val) const;

(2.1)
Stage 1: Determine a conversion specifier.
(2.2)
Stage 2: Extract characters from in and determine a corresponding char value for the format expected by the conversion specification determined in stage 1.
(2.3)
Stage 3: Store results.

Stage 1:
The function initializes local variables via fmtflags flags = str.flags(); fmtflags basefield = (flags & ios_base::basefield); fmtflags uppercase = (flags & ios_base::uppercase); fmtflags boolalpha = (flags & ios_base::boolalpha);
For conversion to an integral type, the function determines the integral conversion specifier as indicated in Table 95 .

The table is ordered.

That is, the first line whose condition is true applies.
Table 95 — Integer conversions [tab:facet.num.get.int]
🔗
State
stdio equivalent
🔗
basefield == oct
%o
🔗
basefield == hex
%X
🔗
basefield == 0
%i
🔗
signed integral type
%d
🔗
unsigned integral type
%u

For conversions to a floating-point type the specifier is %g.
For conversions to void* the specifier is %p.
A length modifier is added to the conversion specification, if needed, as indicated in Table 96 .
Table 96 — Length modifier [tab:facet.num.get.length]
🔗
Type
Length modifier
🔗
short
h
🔗
unsigned short
h
🔗
long
l
🔗
unsigned long
l
🔗
long long
ll
🔗
unsigned long
ll
🔗
double
l
🔗
long double
L
Stage 2:
If in == end then stage 2 terminates.

Otherwise a charT is taken from in and local variables are initialized as if by char_type ct = *in; char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atoms]; if (ct == use_facet<numpunct<charT>>(loc).decimal_point() c = '.'; bool discard = ct == use_facet<numpunct<charT>>(loc).thousands_sep() && use_facet<numpunct<charT>>(loc).grouping().length() != 0; where the values src and atoms are defined as if by: static const char src[] = "0123456789abcdefpxABCDEFPX+-"; char_type atoms[sizeof(src)]; use_facet<ctype<charT>>(loc).widen(src, src + sizeof(src), atoms); for this value of loc.
If discard is true, then if '.' has not yet been accumulated, then the position of the character is remembered, but the character is otherwise ignored.

Otherwise, if '.' has already been accumulated, the character is discarded and Stage 2 terminates.

If it is not discarded, then a check is made to determine if c is allowed as the next character of an input field of the conversion specifier returned by Stage 1.

If so, it is accumulated.
If the character is either discarded or accumulated then in is advanced by ++in and processing returns to the beginning of stage 2.
[Example 1:
Given an input sequence of "0x1a.bp+07p",
(3.2.1)
if the conversion specifier returned by Stage 1 is %d, "0" is accumulated;
(3.2.2)
if the conversion specifier returned by Stage 1 is %i, "0x1a" are accumulated;
(3.2.3)
if the conversion specifier returned by Stage 1 is %g, "0x1a.bp+07" are accumulated.
In all cases, the remainder is left in the input.
— end example]
Stage 3:
The sequence of chars accumulated in stage 2 (the field) is converted to a numeric value by the rules of one of the functions declared in the header <cstdlib>:
- (3.3.1)
  For a signed integer value, the function strtoll.
- (3.3.2)
  For an unsigned integer value, the function strtoull.
- (3.3.3)
  For a float value, the function strtof.
- (3.3.4)
  For a double value, the function strtod.
- (3.3.5)
  For a long double value, the function strtold.
The numeric value to be stored can be one of:
- (3.3.6)
  zero, if the conversion function does not convert the entire field.
- (3.3.7)
  the most positive (or negative) representable value, if the field to be converted to a signed integer type represents a value too large positive (or negative) to be represented in val.
- (3.3.8)
  the most positive representable value, if the field to be converted to an unsigned integer type represents a value that cannot be represented in val.
- (3.3.9)
  the converted value, otherwise.
The resultant numeric value is stored in val.

If the conversion function does not convert the entire field, or if the field represents a value outside the range of representable values, ios_base::failbit is assigned to err.

🔗 State	stdio equivalent
🔗 floatfield == ios_base::fixed && !uppercase	%f
🔗 floatfield == ios_base::fixed	%F
🔗 floatfield == ios_base::scientific && !uppercase	%e
🔗 floatfield == ios_base::scientific	%E
🔗 floatfield == (ios_base::fixed \| ios_base::scientific) && !uppercase	%a
🔗 floatfield == (ios_base::fixed \| ios_base::scientific)	%A
🔗 !uppercase	%g
🔗 otherwise	%G

🔗 Type(s)	State	stdio equivalent
🔗 an integral type	showpos	+
🔗	showbase	#
🔗 a floating-point type	showpos	+
🔗	showpoint	#

🔗 State	Location
🔗 adjustfield == ios_base::left	pad after
🔗 adjustfield == ios_base::right	pad before
🔗 adjustfield == internal and a sign occurs in the representation	pad after the sign
🔗 adjustfield == internal and representation after stage 1 began with 0x or 0X	pad after x or X
🔗 otherwise	pad before

🔗 date_order()	Format
🔗 no_order	"%m%d%y"
🔗 dmy	"%d%m%y"
🔗 mdy	"%m%d%y"
🔗 ymd	"%y%m%d"
🔗 ydm	"%y%d%m"

🔗 fprintf	isprint	iswdigit	localeconv	tolower
🔗 fscanf	ispunct	iswgraph	mblen	toupper
🔗 isalnum	isspace	iswlower	mbstowcs	towlower
🔗 isalpha	isupper	iswprint	mbtowc	towupper
🔗 isblank	iswalnum	iswpunct	setlocale	wcscoll
🔗 iscntrl	iswalpha	iswspace	strcoll	wcstod
🔗 isdigit	iswblank	iswupper	strerror	wcstombs
🔗 isgraph	iswcntrl	iswxdigit	strtod	wcsxfrm
🔗 islower	iswctype	isxdigit	strxfrm	wctomb

🔗 State	stdio equivalent
🔗 basefield == oct	%o
🔗 basefield == hex	%X
🔗 basefield == 0	%i
🔗 signed integral type	%d
🔗 unsigned integral type	%u

🔗 Type	Length modifier
🔗 short	h
🔗 unsigned short	h
🔗 long	l
🔗 unsigned long	l
🔗 long long	ll
🔗 unsigned long	ll
🔗 double	l
🔗 long double	L

🔗 State	stdio equivalent
🔗 basefield == ios_base::oct	%o
🔗 (basefield == ios_base::hex) && !uppercase	%x
🔗 (basefield == ios_base::hex)	%X
🔗 for a signed integral type	%d
🔗 for an unsigned integral type	%u

🔗 Option	Meaning
🔗 <	Forces the formatted argument to be aligned to the start of the field by inserting n fill characters after the formatted argument where n is the padding width. This is the default for non-arithmetic non-pointer types, charT, and bool, unless an integer presentation type is specified.
🔗 >	Forces the formatted argument to be aligned to the end of the field by inserting n fill characters before the formatted argument where n is the padding width. This is the default for arithmetic types other than charT and bool, pointer types, or when an integer presentation type is specified.
🔗 ^	Forces the formatted argument to be centered within the field by inserting $⌊ \frac{n 2}{2}$

🔗 Option	Meaning
🔗 +	Indicates that a sign should be used for both non-negative and negative numbers. The + sign is inserted before the output of to_chars for non-negative numbers other than negative zero. [Note 5: For negative numbers and negative zero the output of to_chars will already contain the sign so no additional transformation is performed. — end note]
🔗 -	Indicates that a sign should be used for negative numbers and negative zero only (this is the default behavior).
🔗 space	Indicates that a leading space should be used for non-negative numbers other than negative zero, and a minus sign for negative numbers and negative zero.

🔗 Type	Meaning
🔗 b	to_chars(first, last, value, 2); the base prefix is 0b.
🔗 B	The same as b, except that the base prefix is 0B.
🔗 c	Copies the character static_cast<charT>(value) to the output. Throws format_error if value is not in the range of representable values for charT.
🔗 d	to_chars(first, last, value).
🔗 o	to_chars(first, last, value, 8); the base prefix is 0 if value is nonzero and is empty otherwise.
🔗 x	to_chars(first, last, value, 16); the base prefix is 0x.
🔗 X	The same as x, except that it uses uppercase letters for digits above 9 and the base prefix is 0X.
🔗 none	The same as d. [Note 8: If the formatting argument type is charT or bool, the default is instead c or s, respectively. — end note]

🔗 Type	Meaning
🔗 none, c	Copies the character to the output.
🔗 b, B, d, o, x, X	As specified in Table 107 with value converted to the unsigned version of the underlying type.
🔗 ?	Copies the escaped character ([format.string.escaped]) to the output.

🔗 Type	Meaning
🔗 none, s	Copies textual representation, either true or false, to the output.
🔗 b, B, d, o, x, X	As specified in Table 107 for the value static_cast<unsigned char>(value).

🔗 Type	Meaning
🔗 a	If precision is specified, equivalent to to_chars(first, last, value, chars_format::hex, precision) where precision is the specified formatting precision; equivalent to to_chars(first, last, value, chars_format::hex) otherwise.
🔗 A	The same as a, except that it uses uppercase letters for digits above 9 and P to indicate the exponent.
🔗 e	Equivalent to to_chars(first, last, value, chars_format::scientific, precision) where precision is the specified formatting precision, or 6 if precision is not specified.
🔗 E	The same as e, except that it uses E to indicate exponent.
🔗 f, F	Equivalent to to_chars(first, last, value, chars_format::fixed, precision) where precision is the specified formatting precision, or 6 if precision is not specified.
🔗 g	Equivalent to to_chars(first, last, value, chars_format::general, precision) where precision is the specified formatting precision, or 6 if precision is not specified.
🔗 G	The same as g, except that it uses E to indicate exponent.
🔗 none	If precision is specified, equivalent to to_chars(first, last, value, chars_format::general, precision) where precision is the specified formatting precision; equivalent to to_chars(first, last, value) otherwise.

🔗 Type	Meaning
🔗 none, p	If uintptr_t is defined, to_chars(first, last, reinterpret_cast<uintptr_t>(value), 16) with the prefix 0x inserted immediately before the output of to_chars; otherwise, implementation-defined.
🔗 P	The same as p, except that it uses uppercase letters for digits above 9 and the base prefix is 0X.

🔗 Character	Escape sequence
🔗 U+0009 character tabulation	\t
🔗 U+000a line feed	\n
🔗 U+000d carriage return	\r
🔗 U+0022 quotation mark	\"
🔗 U+005c reverse solidus	\\

🔗 Option	Requirements	Meaning
🔗 m	sizeof.(Ts) == 2	Equivalent to: set_separator(STATICALLY-WIDEN<charT>(": "); set_brackets({}, {});
🔗 n	none	Equivalent to: set_brackets({}, {});
🔗 none	none	No effects

🔗	Subclause	Header
🔗 [re.req]	Requirements
🔗 [re.const]	Constants	<regex>
🔗 [re.badexp]	Exception type
🔗 [re.traits]	Traits
🔗 [re.regex]	Regular expression template
🔗 [re.submatch]	Submatches
🔗 [re.results]	Match results
🔗 [re.alg]	Algorithms
🔗 [re.iter]	Iterators
🔗 [re.grammar]	Grammar

🔗 Element	Effect(s) if set
🔗 icase	Specifies that matching of regular expressions against a character container sequence shall be performed without regard to case.
🔗 nosubs	Specifies that no sub-expressions shall be considered to be marked, so that when a regular expression is matched against a character container sequence, no sub-expression matches shall be stored in the supplied match_results object.
🔗 optimize	Specifies that the regular expression engine should pay more attention to the speed with which regular expressions are matched, and less to the speed with which regular expression objects are constructed. Otherwise it has no detectable effect on the program output.
🔗 collate	Specifies that character ranges of the form "[a-b]" shall be locale sensitive.
🔗 ECMAScript	Specifies that the grammar recognized by the regular expression engine shall be that used by ECMAScript in ECMA-262, as modified in [re.grammar]. See also: ECMA-262 15.10
🔗 basic	Specifies that the grammar recognized by the regular expression engine shall be that used by basic regular expressions in POSIX. See also: POSIX, Base Definitions and Headers, Section 9.3
🔗 extended	Specifies that the grammar recognized by the regular expression engine shall be that used by extended regular expressions in POSIX. See also: POSIX, Base Definitions and Headers, Section 9.4
🔗 awk	Specifies that the grammar recognized by the regular expression engine shall be that used by the utility awk in POSIX.
🔗 grep	Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep in POSIX.
🔗 egrep	Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep when given the -E option in POSIX.
🔗 multiline	Specifies that ^ shall match the beginning of a line and $ shall match the end of a line, if the ECMAScript engine is selected.

🔗 Expression	Return type	Requirement
🔗 g.parse(pc)	PC::iterator	Parses format-spec ([format.string]) for type T in the range [pc.begin(), pc.end()) until the first unmatched character. Throws format_error unless the whole range is parsed or the unmatched character is }. [Note 1: This allows formatters to emit meaningful error messages. — end note] Stores the parsed format specifiers in *this and returns an iterator past the end of the parsed range.
🔗 f.format(u, fc)	FC::iterator	Formats u according to the specifiers stored in *this, writes the output to fc.out(), and returns an iterator past the end of the output range. The output shall only depend on u, fc.locale(), fc.arg(n) for any value n of type size_t, and the range [pc.begin(), pc.end()) from the last call to f.parse(pc).

🔗 Element	Effect(s) if set
🔗 match_not_bol	The first character in the sequence [first, last) shall be treated as though it is not at the beginning of a line, so the character `^` in the regular expression shall not match [first, first).
🔗 match_not_eol	The last character in the sequence [first, last) shall be treated as though it is not at the end of a line, so the character `"$"` in the regular expression shall not match [last, last).
🔗 match_not_bow	The expression `"\\b"` shall not match the sub-sequence [first, first).
🔗 match_not_eow	The expression `"\\b"` shall not match the sub-sequence [last, last).
🔗 match_any	If more than one match is possible then any match is an acceptable result.
🔗 match_not_null	The expression shall not match an empty sequence.
🔗 match_continuous	The expression shall only match a sub-sequence that begins at first.
🔗 match_prev_avail	`--first` is a valid iterator position. When this flag is set the flags match_not_bol and match_not_bow shall be ignored by the regular expression algorithms ([re.alg]) and iterators ([re.iter]).
🔗 format_default	When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the ECMAScript replace function in ECMA-262, part 15.5.4.11 String.prototype.replace. In addition, during search and replace operations all non-overlapping occurrences of the regular expression shall be located and replaced, and sections of the input that did not match the expression shall be copied unchanged to the output string.
🔗 format_sed	When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the sed utility in POSIX.
🔗 format_no_copy	During a search and replace operation, sections of the character container sequence being searched that do not match the regular expression shall not be copied to the output string.
🔗 format_first_only	When specified during a search and replace operation, only the first occurrence of the regular expression shall be replaced.

🔗 Value	Error condition
🔗 error_collate	The expression contains an invalid collating element name.
🔗 error_ctype	The expression contains an invalid character class name.
🔗 error_escape	The expression contains an invalid escaped character, or a trailing escape.
🔗 error_backref	The expression contains an invalid back reference.
🔗 error_brack	The expression contains mismatched `[` and `]`.
🔗 error_paren	The expression contains mismatched `(` and `)`.
🔗 error_brace	The expression contains mismatched `{` and `}`.
🔗 error_badbrace	The expression contains an invalid range in a `{}` expression.
🔗 error_range	The expression contains an invalid character range, such as `[b-a]` in most encodings.
🔗 error_space	There is insufficient memory to convert the expression into a finite state machine.
🔗 error_badrepeat	One of `*?+{` is not preceded by a valid regular expression.
🔗 error_complexity	The complexity of an attempted match against a regular expression exceeds a pre-set level.
🔗 error_stack	There is insufficient memory to determine whether the regular expression matches the specified character sequence.

🔗 Narrow character name	Wide character name	Corresponding ctype_base::mask value
🔗 "alnum"	L"alnum"	ctype_base::alnum
🔗 "alpha"	L"alpha"	ctype_base::alpha
🔗 "blank"	L"blank"	ctype_base::blank
🔗 "cntrl"	L"cntrl"	ctype_base::cntrl
🔗 "digit"	L"digit"	ctype_base::digit
🔗 "d"	L"d"	ctype_base::digit
🔗 "graph"	L"graph"	ctype_base::graph
🔗 "lower"	L"lower"	ctype_base::lower
🔗 "print"	L"print"	ctype_base::print
🔗 "punct"	L"punct"	ctype_base::punct
🔗 "space"	L"space"	ctype_base::space
🔗 "s"	L"s"	ctype_base::space
🔗 "upper"	L"upper"	ctype_base::upper
🔗 "w"	L"w"	ctype_base::alnum
🔗 "xdigit"	L"xdigit"	ctype_base::xdigit

🔗 Element	Value
🔗 ready()	m.ready()
🔗 size()	m.size()
🔗 str(n)	m.str(n) for all non-negative integers n < m.size()
🔗 prefix()	m.prefix()
🔗 suffix()	m.suffix()
🔗 (*this)[n]	m[n] for all non-negative integers n < m.size()
🔗 length(n)	m.length(n) for all non-negative integers n < m.size()
🔗 position(n)	m.position(n) for all non-negative integers n < m.size()

🔗 Element	Value
🔗 m.size()	1 + e.mark_count()
🔗 m.empty()	false
🔗 m.prefix().first	first
🔗 m.prefix().second	first
🔗 m.prefix().matched	false
🔗 m.suffix().first	last
🔗 m.suffix().second	last
🔗 m.suffix().matched	false
🔗 m[0].first	first
🔗 m[0].second	last
🔗 m[0].matched	true
🔗 m[n].first	For all integers 0 < n < m.size(), the start of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then last.
🔗 m[n].second	For all integers 0 < n < m.size(), the end of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then last.
🔗 m[n].matched	For all integers 0 < n < m.size(), true if sub-expression n participated in the match, false otherwise.

28.2.2 Primitive numeric output conversion [charconv.to.chars]

28.3.2 Header <locale> synopsis [locale.syn]

28.3.3 Locales [locales]

28.3.3.1 Class locale [locale]

28.3.3.1.1 General [locale.general]

28.3.3.1.2 Types [locale.types]

28.3.3.1.2.1 Type locale​::​category [locale.category]

28.3.3.1.2.2 Class locale​::​facet [locale.facet]

28.3.3.1.2.3 Class locale​::​id [locale.id]

28.3.3.1.3 Constructors and destructor [locale.cons]

28.3.3.1.4 Members [locale.members]

28.3.3.1.5 Operators [locale.operators]

28.3.3.1.6 Static members [locale.statics]

28.3.3.2 locale globals [locale.global.templates]

28.3.3.3 Convenience interfaces [locale.convenience]

28.3.3.3.1 Character classification [classification]

28.3.3.3.2 Character conversions [conversions.character]

28.3.4.2 The ctype category [category.ctype]

28.3.4.2.1 General [category.ctype.general]

28.3.4.2.2 Class template ctype [locale.ctype]

28.3.4.2.2.1 General [locale.ctype.general]

28.3.4.2.2.2 ctype members [locale.ctype.members]

28.3.4.2.2.3 ctype virtual functions [locale.ctype.virtuals]

28.3.4.2.3 Class template ctype_byname [locale.ctype.byname]

28.3.4.2.4 ctype<char> specialization [facet.ctype.special]

28.3.4.2.4.1 General [facet.ctype.special.general]

28.3.4.2.4.2 Destructor [facet.ctype.char.dtor]

28.3.4.2.4.3 Members [facet.ctype.char.members]

28.3.4.2.4.4 Static members [facet.ctype.char.statics]

28.3.4.2.4.5 Virtual functions [facet.ctype.char.virtuals]

28.3.4.2.5 Class template codecvt [locale.codecvt]

28.3.4.2.5.1 General [locale.codecvt.general]

28.3.4.2.5.2 Members [locale.codecvt.members]

28.3.4.2.5.3 Virtual functions [locale.codecvt.virtuals]

28.3.4.2.6 Class template codecvt_byname [locale.codecvt.byname]

28.3.4.3 The numeric category [category.numeric]

28.3.4.3.1 General [category.numeric.general]

28.3.4.3.2 Class template num_get [locale.num.get]

28.3.4.3.2.1 General [locale.num.get.general]

28.3.4.3.2.2 Members [facet.num.get.members]

28.3.4.3.2.3 Virtual functions [facet.num.get.virtuals]

28.3.4.3.3 Class template num_put [locale.nm.put]

28.3.4.3.3.1 General [locale.nm.put.general]

28.3.4.3.3.2 Members [facet.num.put.members]

28.3.4.3.3.3 Virtual functions [facet.num.put.virtuals]

28.3.4.4 The numeric punctuation facet [facet.numpunct]

28.3.4.4.1 Class template numpunct [locale.numpunct]

28.3.4.4.1.1 General [locale.numpunct.general]

28.3.4.4.1.2 Members [facet.numpunct.members]

28.3.4.4.1.3 Virtual functions [facet.numpunct.virtuals]

28.3.4.4.2 Class template numpunct_byname [locale.numpunct.byname]

28.3.4.5 The collate category [category.collate]

28.3.4.5.1 Class template collate [locale.collate]

28.3.4.5.1.1 General [locale.collate.general]

28.3.4.5.1.2 Members [locale.collate.members]

28.3.4.5.1.3 Virtual functions [locale.collate.virtuals]

28.3.4.5.2 Class template collate_byname [locale.collate.byname]

28.3.4.6 The time category [category.time]

28.3.4.6.1 General [category.time.general]

28.3.4.6.2 Class template time_get [locale.time.get]

28.3.4.6.2.1 General [locale.time.get.general]

28.3.4.6.2.2 Members [locale.time.get.members]

28.3.4.6.2.3 Virtual functions [locale.time.get.virtuals]

28.3.4.6.3 Class template time_get_byname [locale.time.get.byname]

28.3.4.6.4 Class template time_put [locale.time.put]

28.3.4.6.4.1 General [locale.time.put.general]

28.3.4.6.4.2 Members [locale.time.put.members]

28.3.4.6.4.3 Virtual functions [locale.time.put.virtuals]

28.3.4.6.5 Class template time_put_byname [locale.time.put.byname]

28.3.4.7 The monetary category [category.monetary]

28.3.4.7.1 General [category.monetary.general]

28.3.4.7.2 Class template money_get [locale.money.get]

28.3.4.7.2.1 General [locale.money.get.general]

28.3.4.7.2.2 Members [locale.money.get.members]

28.3.4.7.2.3 Virtual functions [locale.money.get.virtuals]

28.3.4.7.3 Class template money_put [locale.money.put]

28.3.4.7.3.1 General [locale.money.put.general]

28.3.4.7.3.2 Members [locale.money.put.members]

28.3.4.7.3.3 Virtual functions [locale.money.put.virtuals]

28.3.4.7.4 Class template moneypunct [locale.moneypunct]

28.3.3.1.2.1 Type locale::category [locale.category]

28.3.3.1.2.2 Class locale::facet [locale.facet]

28.3.3.1.2.3 Class locale::id [locale.id]

28.4.2.5 Class text_encoding::aliases_view [text.encoding.aliases]

28.4.2.6 Enumeration text_encoding::id [text.encoding.id]

28.6.4 Namespace std::regex_constants [re.const]