25 Localization library [localization]

25.4 Standard locale categories [locale.categories]

25.4.3 The numeric punctuation facet [facet.numpunct]

25.4.3.1 Class template numpunct [locale.numpunct]

namespace std {
  template <class charT>
    class numpunct : public locale::facet {
    public:
      using char_type   = charT;
      using string_type = basic_string<charT>;

      explicit numpunct(size_t refs = 0);

      char_type    decimal_point()   const;
      char_type    thousands_sep()   const;
      string       grouping()        const;
      string_type  truename()        const;
      string_type  falsename()       const;

      static locale::id id;

    protected:
      ~numpunct();                // virtual
      virtual char_type    do_decimal_point() const;
      virtual char_type    do_thousands_sep() const;
      virtual string       do_grouping()      const;
      virtual string_type  do_truename()      const;      // for bool
      virtual string_type  do_falsename()     const;      // for bool
    };
}
numpunct<> specifies numeric punctuation.
The specializations required in Table 69 ([locale.category]), namely numpunct<​wchar_­t> and numpunct<char>, provide classic "C" numeric formats, i.e., they contain information equivalent to that contained in the "C" locale or their wide character counterparts as if obtained by a call to widen.
The syntax for number formats is as follows, where digit represents the radix set specified by the fmtflags argument value, and thousands-sep and decimal-point are the results of corresponding numpunct<charT> members.
Integer values have the format:
integer   ::= [sign] units
sign      ::= plusminus
plusminus ::= '+' | '-'
units     ::= digits [thousands-sep units]
digits    ::= digit [digits]
and floating-point values have:
floatval ::= [sign] units [decimal-point [digits]] [e [sign] digits] |
             [sign]        decimal-point  digits   [e [sign] digits]
e        ::= 'e' | 'E'
where the number of digits between thousands-seps is as specified by do_­grouping().
For parsing, if the digits portion contains no thousands-separators, no grouping constraint is applied.

25.4.3.1.1 numpunct members [facet.numpunct.members]

char_type decimal_point() const;
Returns: do_­decimal_­point().
char_type thousands_sep() const;
Returns: do_­thousands_­sep().
string grouping() const;
Returns: do_­grouping().
string_type truename() const; string_type falsename() const;
Returns: do_­truename() or do_­falsename(), respectively.

25.4.3.1.2 numpunct virtual functions [facet.numpunct.virtuals]

char_type do_decimal_point() const;
Returns: A character for use as the decimal radix separator.
The required specializations return '.' or L'.'.
char_type do_thousands_sep() const;
Returns: A character for use as the digit group separator.
The required specializations return ',' or L','.
string do_grouping() const;
Returns: A basic_string<char> vec used as a vector of integer values, in which each element vec[i] represents the number of digits242 in the group at position i, starting with position 0 as the rightmost group.
If vec.size() <= i, the number is the same as group (i - 1); if (i < 0 || vec[i] <= 0 || vec[i] == CHAR_­MAX), the size of the digit group is unlimited.
The required specializations return the empty string, indicating no grouping.
string_type do_truename() const; string_type do_falsename() const;
Returns: A string representing the name of the boolean value true or false, respectively.
In the base class implementation these names are "true" and "false", or L"true" and L"false".
Thus, the string "\003" specifies groups of 3 digits each, and "3" probably indicates groups of 51 (!) digits each, because 51 is the ASCII value of "3".

25.4.3.2 Class template numpunct_­byname [locale.numpunct.byname]

namespace std {
  template <class charT>
    class numpunct_byname : public numpunct<charT> {
    // this class is specialized for char and wchar_­t.
    public:
      using char_type   = charT;
      using string_type = basic_string<charT>;

      explicit numpunct_byname(const char*, size_t refs = 0);
      explicit numpunct_byname(const string&, size_t refs = 0);

    protected:
      ~numpunct_byname();
    };
}