Namespaces
Variants

std:: formatter < pair-or-tuple >

From cppreference.net
C++
Text processing library
Formatting library
Standard format specification
Formatting functions
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
Format strings
(C++20) (C++20) (C++20)
(C++26)
Formatting concepts
(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)
Formatting arguments
(C++20)
(C++20)
(C++20) (C++20) (C++20)
(C++20) (deprecated in C++26)
(C++20) (C++20)
Format error
(C++20)
Défini dans l'en-tête <format>
template < class CharT, std:: formattable < CharT > ... Ts >
struct formatter < /*pair-or-tuple*/ < Ts... > , CharT > ;
(depuis C++23)

La spécialisation de modèle de std::formatter pour std::pair et std::tuple permet aux utilisateurs de convertir une paire ou un tuple en sa représentation textuelle sous forme de collection d'éléments en utilisant les fonctions de formatage .

Le nom d'exposition uniquement /*pair-or-tuple*/ désigne soit le modèle de classe std::pair soit std::tuple .

Cette spécialisation satisfait aux exigences Formatter si ( std:: formattable < const Ts, CharT > && ... ) est true . Elle satisfait toujours aux exigences BasicFormatter .

Table des matières

Spécification du format

La syntaxe de tuple-format-spec est :

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

Le tuple-fill-and-align est interprété de la même manière qu'un fill-and-align sauf que le fill dans tuple-fill-and-align est tout caractère autre que { , } , ou : .

La width est décrite dans la spécification standard de format width .

Le tuple-type modifie la manière dont un tuple est formaté, certaines options n'étant valides qu'avec certains types d'arguments.

Les types de présentation de tuple disponibles sont :

  • m : Indique que les crochets ouvrants et fermants doivent être "" tandis que le séparateur doit être ": " .
  • Si m est choisi comme tuple-type , le programme est mal formé sauf si sizeof... ( Ts ) == 2 est true .
  • n : Indique que le séparateur, les crochets d'ouverture et de fermeture doivent être "" .

Objets membres

Nom du membre Définition
underlying_ (privé) tuple des formateurs sous-jacents de type std:: tuple < std:: formatter < std:: remove_cvref_t < Ts > , CharT > ... >
( objet membre d'exposition uniquement* )
separator_ (privé) chaîne représentant le séparateur du résultat formaté du tuple (valeur par défaut ", " )
( objet membre d'exposition uniquement* )
opening-bracket_ (privé) chaîne représentant le crochet ouvrant du résultat formaté du tuple (valeur par défaut "(" )
( objet membre d'exposition uniquement* )
closing-bracket_ (privé) chaîne représentant le crochet fermant du résultat formaté du tuple (valeur par défaut ")" )
( objet membre d'exposition uniquement* )

Fonctions membres

set_separator
définit un séparateur spécifié pour le résultat formaté du tuple
(fonction membre publique)
set_brackets
définit des crochets d'ouverture et de fermeture spécifiés pour le résultat formaté du tuple
(fonction membre publique)
parse
analyse le spécificateur de format comme spécifié par tuple-format-spec
(fonction membre publique)
format
écrit la sortie formatée du tuple comme spécifié par tuple-format-spec
(fonction membre publique)

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

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

Affecte sep à separator_ .

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

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

Attribue opening et closing respectivement à opening-bracket_ et closing-bracket_ .

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

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

Analyse les spécificateurs de format en tant que tuple-format-spec et stocke les spécificateurs analysés dans l'objet courant.

Si tuple-type ou l'option n est présente, les valeurs de opening-bracket , closing-bracket , et separator sont modifiées selon les besoins.

Pour chaque élément e dans underlying_ , appelle e. parse ( ctx ) pour analyser un format-spec vide et, si e. set_debug_format ( ) est une expression valide, appelle e. set_debug_format ( ) .

Retourne un itérateur après la fin du tuple-format-spec .

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*/ désigne :

  • const /*pair-or-tuple*/ , si ( std:: formattable < const Ts, CharT > && ... ) est true ,
  • /*pair-or-tuple*/ sinon.

Écrit les éléments suivants dans ctx. out ( ) tel que spécifié par tuple-format-spec , dans l'ordre :

  • opening-bracket_ ,
  • pour chaque index I dans [ ​ 0 ​ , sizeof... ( Ts ) ) :
  • si I ! = 0 , separator_ ,
  • le résultat de l'écriture de std :: get < I > ( elems ) via std :: get < I > ( underlying_ ) , et
  • closing-bracket_ .

Retourne un itérateur situé après la fin de la plage de sortie.

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3892 C++23 le formatage des tuples imbriqués était incorrect corrigé

Voir aussi

(C++20)
définit les règles de formatage pour un type donné
(modèle de classe)