std::num_put::put, std::num_put::do_put

From Cppreference

C++ Standard Library
Language Utilities library Strings library Containers library Algorithms library Iterators library Numerics library Input/output library Localizations library Regular expressions library (C++11) Atomic operations library (C++11) Thread support library (C++11)
Localizations library
Locales and facets locale use_facet has_facet Character classification isspace isblank (C++11) iscntrl isupper islower isalpha isdigit ispunct isxdigit isalnum isprint isgraph Conversions toupper tolower wstring_convert (C++11) wbuffer_convert (C++11) Facet category base classes ctype_base codecvt_base messages_base time_base money_base Facet categories ctype ctype<char> codecvt collate messages time_get time_put num_get num_put numpunct money_get money_put moneypunct Locale-specific facets ctype_byname ctype_byname<char> codecvt_byname messages_byname collate_byname time_get_byname time_put_byname numpunct_byname moneypunct_byname Code conversion facets codecvt_utf8 (C++11) codecvt_utf16 (C++11) codecvt_utf8_utf16 (C++11) codecvt_mode (C++11) C locale setlocale lconv LC_ALL LC_COLLATE LC_CTYPE LC_MONETARY LC_NUMERIC LC_TIME
std::num_put
Member functions num_put::num_put num_put::~num_put num_put::put num_put::do_put

Defined in header <locale>
public: iter_type put( iter_type out, std::ios_base& str, char_type fill, bool v) const; iter_type put( iter_type out, std::ios_base& str, char_type fill, long v) const; iter_type put( iter_type out, std::ios_base& str, char_type fill, long long v) const; iter_type put( iter_type out, std::ios_base& str, char_type fill, unsigned long v) const; iter_type put( iter_type out, std::ios_base& str, char_type fill, unsigned long long v) const; iter_type put( iter_type out, std::ios_base& str, char_type fill, double v) const; iter_type put( iter_type out, std::ios_base& str, char_type fill, long double v) const; iter_type put( iter_type out, std::ios_base& str, char_type fill, const void* v) const;	(1)
protected: iter_type do_put( iter_type out, std::ios_base& str, char_type fill, bool v) const; iter_type do_put( iter_type out, std::ios_base& str, char_type fill, long v) const; iter_type do_put( iter_type out, std::ios_base& str, char_type fill, long long v) const; iter_type do_put( iter_type out, std::ios_base& str, char_type fill, unsigned long) const; iter_type do_put( iter_type out, std::ios_base& str, char_type fill, unsigned long long) const; iter_type do_put( iter_type out, std::ios_base& str, char_type fill, double v) const; iter_type do_put( iter_type out, std::ios_base& str, char_type fill, long double v) const; iter_type do_put( iter_type out, std::ios_base& str, char_type fill, const void* v) const;	(2)

1) public member function, calls the protected virtual member function do_put of the most derived class.

2) writes characters to the output sequence out which represent the value of val, formatted as requested by the formatting flags str.flags() and the std::numpunct and std::ctype facets of the locale imbued in the stream str. This function is called by all formatted output stream operators, such as std::cout << n;.

Conversion occurs in four stages

Contents 1 Stage 1: conversion specifier selection 2 Stage 2: locale-specific conversion 3 Stage 3: padding 4 Stage 4: output 5 Return value 6 Notes 7 Example 8 See also

[edit] Stage 1: conversion specifier selection

• I/O format flags are obtained, as if by

fmtflags basefield = (str.flags() & std::ios_base::basefield);

fmtflags uppercase = (str.flags() & std::ios_base::uppercase);

fmtflags floatfield = (str.flags() & std::ios_base::floatfield);

fmtflags showpos = (str.flags() & std::ios_base::showpos);

fmtflags showbase = (str.flags() & std::ios_base::showbase);

• If the type of val is bool
  • If boolalpha == 0, then converts val to type int and performs integer output.
  • If boolalpha != 0 obtains std::use_facet<std::numpunct<charT>>(str.getloc()).truename() if val == true or std::use_facet<std::numpunct<charT>>(str.getloc()).falsename() if val == false, and outputs each successive character c of that string to out with *out++ = c. No further processing is done in this case, the function returns out.
• If the type of val is an integer type, the the first applicable choice of the following five is selected:

If basefield == oct, will use conversion specifier %o

If basefield == hex && !uppercase, will use conversion specifier %x

If basefield == hex, will use conversion specifier %X

If the type of v is signed, will use conversion specifier %d

If the type of v is unsigned, will use conversion specifier %u

• For integer types, length modifier is added to the conversion specification if necessary: l for long and unsigned long, ll for long long and unsigned long long.
• If the type of val is a floating-point type, the the first applicable choice of the following five is selected:

If floatfield == std::ios_base::fixed, will use conversion specifier %f

If floatfield == std::ios_base::scientific && !uppercase, will use conversion specifier %e

If floatfield == std::ios_base::scientific, will use conversion specifier %E

If floatfield == (std::ios_base::fixed | std::ios_base::scientific) && !uppercase, will use conversion specifier %a (since C++11)

If floatfield == std::ios_base::fixed | std::ios_base::scientific, will use conversion specifier %A (since C++11)

If !uppercase, will use conversion specifier %g

otherwise, will use conversion specifier %G

• • If the type of v is long double, will the length modifier L is added to the conversion specifier.
  • Additionally, if floatfield != (ios_base::fixed | ios_base::scientific), then precision modifier is added, set to str.precision()
• For both integer and floating-point types, if showbase is set, the modifier # is prepended. If showpos is set, the modifier + is prepended.
• If the type of v is void*, will use conversion specifier %p
• A narrow character string is created as if by a call to std::printf(spec, val) in the "C" locale, where spec is the chosen conversion specifier.

[edit] Stage 2: locale-specific conversion

• Every character c obtained in Stage 1, other than the decimal point '.', is converted to CharT by calling std::use_facet<std::ctype<CharT>>(str.getloc()).widen(c).
• For arithmetic types, the thousands separator character, obtained from std::use_facet<std::numpunct<CharT>>(str.getloc()).thousands_sep(), is inserted into the sequence according to the grouping rules provided by std::use_facet<std::numpunct<CharT>>(str.getloc()).grouping()
• Decimal point characters ('.') are replaced by std::use_facet<std::numpunct<CharT>>(str.getloc()).decimal_point()

[edit] Stage 3: padding

• The adjustment flag is obtained as if by std::fmtflags adjustfield = (flags & (std::ios_base::adjustfield)) and examined to identify padding location, as follows

If adjustfield == std::ios_base::left, will pad after

If adjustfield == std::ios_base::right, will pad before

If adjustfield == internal and a sign character occurs in the representation, will pad after the sign

If adjustfield == internal and Stage 1 representation began with 0x or 0X, will pad after the x or X

otherwise, will pad before

• If str.width() is non-zero (e.g. std::setw was just used) and the number of CharT's after Stage 2 is less than str.width(), then copies of the fill character are inserted at the position indicated by padding to bring the length of the sequence to str.width().

[edit] Stage 4: output

Every suffessive character c from the sequence of CharT's from Stage 3 is output as if by *out++ = c.

[edit] Return value

out

[edit] Notes

The leading zero generated by the conversion specification #o (resulting from the combination of std::showbase and std::oct for example) is not counted as a padding character.

[edit] Example

This section is incomplete

[edit] See also

operator<<	inserts formatted data (public member function)