std::num_put<CharT,OutputIt>:: put, std::num_put<CharT,OutputIt>:: do_put

Die Konvertierung erfolgt in vier Stufen:

Stufe 1: Auswahl des Konvertierungsspezifizierers

• I/O-Format-Flags werden abgerufen, als ob durch

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

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

• Wenn der Typ von val bool ist:
  • Wenn boolalpha == 0 , dann wird val in den Typ int konvertiert und Integer-Ausgabe durchgeführt.
  • Wenn boolalpha ! = 0 , wird std:: use_facet < std:: numpunct < CharT >> ( str. getloc ( ) ) . truename ( ) abgerufen, falls val == true , oder std:: use_facet < std:: numpunct < CharT >> ( str. getloc ( ) ) . falsename ( ) falls val == false , und jedes aufeinanderfolgende Zeichen c dieser Zeichenkette wird mit * out ++ = c an out ausgegeben. In diesem Fall erfolgt keine weitere Verarbeitung, die Funktion gibt out zurück.
• Wenn der Typ von val ein Integer-Typ ist, wird die erste zutreffende Option der folgenden ausgewählt:
  • Wenn basefield == oct , wird Konvertierungsspezifizierer % o verwendet.
  • Wenn basefield == hex && ! uppercase , wird Konvertierungsspezifizierer % x verwendet.
  • Wenn basefield == hex , wird Konvertierungsspezifizierer % X verwendet.
  • Wenn der Typ von val vorzeichenbehaftet ist, wird Konvertierungsspezifizierer % d verwendet.
  • Wenn der Typ von val vorzeichenlos ist, wird Konvertierungsspezifizierer % u verwendet.
• Für Integer-Typen wird bei Bedarf ein Längenmodifikator zur Konvertierungsspezifikation hinzugefügt: l für long und unsigned long , ll für long long und unsigned long long (seit C++11) .
• Wenn der Typ von val ein Gleitkommatyp ist, wird die erste zutreffende Option der folgenden ausgewählt:

• Wenn floatfield == std:: ios_base :: scientific && ! uppercase , wird der Konvertierungsspezifizierer % e verwendet.
• Wenn floatfield == std:: ios_base :: scientific , wird der Konvertierungsspezifizierer % E verwendet.

• Falls ! uppercase , wird der Konvertierungsspezifizierer % g verwendet.
• Andernfalls wird der Konvertierungsspezifizierer % G verwendet.

Außerdem:

• Wenn der Typ von val long double ist, wird die Längenangabe L zum Konvertierungsspezifizierer hinzugefügt.
• Wenn der Typ von val ein Gleitkommatyp ist und floatfield ! = ( ios_base :: fixed | ios_base :: scientific ) (seit C++11) , wird die Genauigkeitsangabe hinzugefügt und auf str. precision ( ) gesetzt. Andernfalls wird keine Genauigkeit angegeben.

• Für sowohl Ganzzahl- als auch Gleitkommatypen wird, wenn showpos gesetzt ist, das Modifikatorzeichen + vorangestellt.
• Für Ganzzahltypen wird, wenn showbase gesetzt ist, das Modifikatorzeichen # vorangestellt.
• Für Gleitkommatypen wird, wenn showpoint gesetzt ist, das Modifikatorzeichen # vorangestellt.
• Wenn der Typ von val void * ist, wird der Konvertierungsspezifizierer % p verwendet.
• Eine Zeichenkette in schmaler Zeichenkodierung wird erstellt, als ob durch einen Aufruf von std:: printf ( spec, val ) im "C"-Locale, wobei spec der gewählte Konvertierungsspezifizierer ist.

Stufe 2: Locale-spezifische Konvertierung

• Jedes Zeichen c aus Stufe 1, außer dem Dezimalpunkt '.' , wird durch Aufruf von std:: use_facet < std:: ctype < CharT >> ( str. getloc ( ) ) . widen ( c ) in CharT konvertiert.
• Für arithmetische Typen wird das Tausendertrennzeichen, ermittelt aus std:: use_facet < std:: numpunct < CharT >> ( str. getloc ( ) ) . thousands_sep ( ) , gemäß den Gruppierungsregeln von std:: use_facet < std:: numpunct < CharT >> ( str. getloc ( ) ) . grouping ( ) in die Sequenz eingefügt.
• Dezimalpunkt-Zeichen ( '.' ) werden durch std:: use_facet < std:: numpunct < CharT >> ( str. getloc ( ) ) . decimal_point ( ) ersetzt.

Stufe 3: Padding

• Das Anpassungsflag wird erhalten, als ob durch std :: fmtflags adjustfield = ( flags & ( std:: ios_base :: adjustfield ) ) und wird untersucht, um die Auffüllposition zu identifizieren, wie folgt:
  • Wenn adjustfield == std:: ios_base :: left , wird nachher aufgefüllt.
  • Wenn adjustfield == std:: ios_base :: right , wird vorher aufgefüllt.
  • Wenn adjustfield == std:: ios_base :: internal und ein Vorzeichen in der Darstellung vorkommt, wird nach dem Vorzeichen aufgefüllt.
  • Wenn adjustfield == std:: ios_base :: internal und die Stufe-1-Darstellung mit 0x oder 0X begann, wird nach dem x oder X aufgefüllt.
  • Andernfalls wird vorher aufgefüllt.
• Wenn str. width ( ) ungleich Null ist (z.B. wurde gerade std::setw verwendet) und die Anzahl der CharT nach Stufe 2 kleiner ist als str. width ( ) , dann werden Kopien des fill -Zeichens an der durch die Auffüllung angegebenen Position eingefügt, um die Länge der Sequenz auf str. width ( ) zu bringen.

In jedem Fall wird str. width ( 0 ) aufgerufen, um die Effekte von std::setw aufzuheben.

Stufe 4: Ausgabe

Jeder aufeinanderfolgende Zeichen c aus der Sequenz von CharT 's aus Stufe 3 wird ausgegeben, als ob durch * out ++ = c .

Parameter

Rückgabewert

out

Hinweise

Die führende Null, die durch die Konvertierungsspezifikation #o (resultierend aus der Kombination von std::showbase und std::oct zum Beispiel) erzeugt wird, zählt nicht als Auffüllzeichen.

Beispiel

#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 out, std::ios_base& str,
                     char_type fill, long val) const
    {
        return std::num_put<char>::do_put(out, str, fill, val * val);
    }
    iter_type do_put(iter_type out, std::ios_base& str,
                     char_type fill, unsigned long val) const
    {
        return std::num_put<char>::do_put(out, str, fill, val * val);
    }
};
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';
}

2.71
36 144

#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, const base& 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;
}

10

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch