Namensräume
Varianten
Aktionen

std::formatter<pair-or-tuple>

Von cppreference.com
< cpp‎ | utility‎ | format
 
C++
 
Textverarbeitungsbibliothek
 
Formatierungsbibliothek
Standardformat-Spezifikation
Formatierungsfunktionen
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
Format-Strings
(C++20)(C++20)(C++20)
(C++26)
Formatierungs-Konzepte
(C++23)
Formatter
(C++20)
formatter<pair-or-tuple>
(C++23)
(C++23)
(C++23)
(C++23)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
(C++23)
(C++23)
Formatierungs-Argumente
(C++20)
(C++20)
(C++20)(C++20)(C++20)
(C++20) (veraltet in C++26)
(C++20)(C++20)
Format-Fehler
(C++20)
 
Definiert in Header <format>
template< class CharT, std::formattable<CharT>... Ts >
struct formatter</*pair-or-tuple*/<Ts...>, CharT>;
 (seit C++23)

Die Template-Spezialisierung von std::formatter für std::pair und std::tuple ermöglicht es Benutzern, ein Paar oder ein Tupel mit Formatierungsfunktionen in seine textuelle Darstellung als Sammlung von Elementen umzuwandeln.

Der expositions-only Name /*pair-or-tuple*/ bezeichnet entweder die Klassenvorlage std::pair oder std::tuple.

Diese Spezialisierung erfüllt die Formatter-Anforderungen, wenn (std::formattable<const Ts, CharT> && ...) true ist. Sie erfüllt immer die BasicFormatter-Anforderungen.

Inhalt

[edit] Format-Spezifikation

Die Syntax von tuple-format-spec ist

tuple-fill-and-align (optional) width (optional) tuple-type (optional)

Die tuple-fill-and-align wird genauso interpretiert wie eine fill-and-align, außer dass die Füllzeichen in tuple-fill-and-align jedes Zeichen außer {, } oder : sein können.

Die width ist in Standard-Formatbreitenspezifikation beschrieben.

Der tuple-type ändert die Art und Weise, wie ein Tupel formatiert wird, wobei bestimmte Optionen nur mit bestimmten Argumenttypen gültig sind.

Die verfügbaren Tupel-Präsentationstypen sind

  • m: Gibt an, dass sowohl die öffnenden als auch die schließenden Klammern "" sein sollen, während das Trennzeichen ": " sein soll.
  • Wenn m als tuple-type gewählt wird, ist das Programm schlecht geformt, es sei denn, sizeof...(Ts) == 2 ist true.
  • n: Gibt an, dass Trennzeichen, öffnende und schließende Klammern "" sein sollen.

[edit] Member objects

Member-Name Definition
underlying_ (private) Tupel aus zugrunde liegenden Formatter vom Typ std::tuple<std::formatter<std::remove_cvref_t<Ts>, CharT>...>
((exposition-only member object*)
separator_ (private) Ein String, der das Trennzeichen des formatierten Tupelergebnisses repräsentiert (Standard ist ", ").
((exposition-only member object*)
opening-bracket_ (private) Ein String, der die öffnende Klammer des formatierten Tupelergebnisses repräsentiert (Standard ist "(").
((exposition-only member object*)
closing-bracket_ (private) Ein String, der die schließende Klammer des formatierten Tupelergebnisses repräsentiert (Standard ist ")").
((exposition-only member object*)

[edit] Member functions

set_separator
 Setzt ein angegebenes Trennzeichen für das formatierte Tupelergebnis.
(öffentliche Memberfunktion)
set_brackets
 Setzt eine angegebene öffnende und schließende Klammer für das formatierte Tupelergebnis.
(öffentliche Memberfunktion)
parse
 Parst den Format-Spezifikator gemäß tuple-format-spec.
(öffentliche Memberfunktion)
format
 Schreibt die formatierte Tupelausgabe gemäß tuple-format-spec.
(öffentliche Memberfunktion)

std::formatter<pair-or-tuple>::set_separator

constexpr void set_separator( std::basic_string_view<CharT> sep ) noexcept;

Weist sep separator_ zu.

std::formatter<pair-or-tuple>::set_brackets

constexpr void set_brackets( std::basic_string_view<CharT> opening,
                             std::basic_string_view<CharT> closing ) noexcept;

Weist opening und closing opening-bracket_ bzw. closing-bracket_ zu.

std::formatter<pair-or-tuple>::parse

template< class ParseContext >
constexpr auto parse( ParseContext& ctx ) -> ParseContext::iterator;

Parst die Format-Spezifikatoren als tuple-format-spec und speichert die geparsten Spezifikatoren im aktuellen Objekt.

Wenn tuple-type oder die Option n vorhanden ist, werden die Werte von opening-bracket, closing-bracket und separator entsprechend modifiziert.

Für jedes Element e in underlying_ wird e.parse(ctx) aufgerufen, um einen leeren format-spec zu parsen, und falls e.set_debug_format() ein gültiger Ausdruck ist, wird e.set_debug_format() aufgerufen.

Gibt einen Iterator nach dem Ende des tuple-format-spec zurück.

std::formatter<pair-or-tuple>::format

template< class FormatContext >

FormatContext::iterator

format( /*maybe-const-pair-or-tuple*/<Ts...>& elems, FormatContext& ctx ) const;

/*maybe-const-pair-or-tuple*/ bezeichnet

  • const /*pair-or-tuple*/, wenn (std::formattable<const Ts, CharT> && ...) true ist,
  • /*pair-or-tuple*/ andernfalls.

Schreibt das Folgende in ctx.out() gemäß tuple-format-spec, in dieser Reihenfolge

  • opening-bracket_,
  • für jeden Index I in [​0​, sizeof...(Ts))
  • wenn I != 0, separator_,
  • das Ergebnis des Schreibens von std::get<I>(elems) über std::get<I>(underlying_), und
  • closing-bracket_.

Gibt einen Iterator nach dem Ende des Ausgabe-Bereichs zurück.

[edit] Defect reports

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

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 3892 C++23 Die Formatierung von verschachtelten Tupeln war fehlerhaft. korrigiert

[edit] Siehe auch

(C++20)
 definiert Formatierungsregeln für einen gegebenen Typ
(Klassentemplate) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/utility/format/tuple_formatter&oldid=171289"