std::num_put::do_put

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

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 v, 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.

Stage 1: conversion specifier selection

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

fmtflags basefield =(str.flags()&std::ios_base::basefieldfmtflags uppercase =(str.flags()&std::ios_base::uppercasefmtflags floatfield =(str.flags()&std::ios_base::floatfieldfmtflags showpos =(str.flags()&std::ios_base::showposfmtflags showbase =(str.flags()&std::ios_base::showbasefmtflags showpoint =(str.flags()&std::ios_base::showpoint

• If the type of v is bool

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 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 !uppercase, will use conversion specifier %g otherwise, will use conversion specifier %G

• If the type of v is long double, the length modifier L is added to the conversion specifier.

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).

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 ==std::ios_base::internal and a sign character occurs in the representation, will pad after the sign If adjustfield ==std::ios_base::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().

In any case, str.width(0) is called to cancel the effects of std::setw.

Stage 4: output

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

Parameters

Return value

out.

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.

Example

Output a number using the facet directly, and demonstrate user-defined facet.

​

#include <iostream>
#include <locale>
 
// this custom num_put outputs squares of all integers (except long long)
struct squaring_num_put : std::num_put<char> {
    iter_type do_put(iter_type s, std::ios_base& f,
                     char_type fill, long v) const
    {
        return std::num_put<char>::do_put(s, f, fill, v*v 
    }
 
    iter_type do_put(iter_type s, std::ios_base& f,
                     char_type fill, unsigned long v) const
    {
        return std::num_put<char>::do_put(s, f, fill, v*v
    }
};
 
int main()
{
    auto& facet = std::use_facet<std::num_put<char>>(std::locale()
    facet.put(std::cout, std::cout, '0', 2.71
    std::cout << '\n';
 
    std::cout.imbue(std::locale(std::cout.getloc(), new squaring_num_put)
    std::cout << 6 << ' ' << -12 << '\n';
}

​

Output:

​

2.71
36 144

​

An implementation of operator<< for a user-defined type.

​

#include <iostream>
#include <iterator>
#include <locale>
 
struct base { long x = 10; };
 
template <class CharT, class Traits>
std::basic_ostream<CharT, Traits>&
    operator<< (std::basic_ostream<CharT, Traits>& os, base const& b)
{
    try {
        typename std::basic_ostream<CharT, Traits>::sentry s(os
        if (s)
        {
            std::ostreambuf_iterator<CharT, Traits> it(os
            std::use_facet<std::num_put<CharT>>(os.getloc())
                .put(it, os, os.fill(), b.x
        }
    } catch (...) {
        // set badbit on os and rethrow if required
    }
    return os;
}
 
int main()
{
    base b;
 
    std::cout << b;
}

​

Output:

​

10

​

See also

 © cppreference.com

Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.

http://en.cppreference.com/w/cpp/locale/num_put/put