std:: formatter < pair-or-tuple >
|
Definido en el encabezado
<format>
|
||
|
template
<
class
CharT,
std::
formattable
<
CharT
>
...
Ts
>
struct formatter < /*pair-or-tuple*/ < Ts... > , CharT > ; |
(desde C++23) | |
La especialización de plantilla de std::formatter para std::pair y std::tuple permite a los usuarios convertir un par o una tupla a su representación textual como una colección de elementos usando funciones de formato .
El nombre de solo exposición /*pair-or-tuple*/ denota ya sea la plantilla de clase std::pair o std::tuple .
Esta especialización cumple con los requisitos Formatter si ( std:: formattable < const Ts, CharT > && ... ) es true . Siempre cumple con los requisitos BasicFormatter .
Contenidos |
Especificación de formato
La sintaxis de tuple-format-spec es:
| tuple-fill-and-align (opcional) width (opcional) tuple-type (opcional) | |||||||||
El
tuple-fill-and-align
se interpreta de la misma manera que un
fill-and-align
excepto que el
fill
en
tuple-fill-and-align
es cualquier carácter distinto de
{
,
}
, o
:
.
El width se describe en la especificación estándar de formato width .
El tuple-type cambia la forma en que se formatea una tupla, con ciertas opciones válidas únicamente con tipos de argumentos específicos.
Los tipos de presentación de tupla disponibles son:
-
m: Indica que tanto los corchetes de apertura como de cierre deben ser "" mientras que el separador debe ser ": " .
-
-
Si
mse elige como el tuple-type , el programa está mal formado a menos que sizeof... ( Ts ) == 2 sea true .
-
Si
-
n: Indica que el separador, los corchetes de apertura y cierre deben ser "" .
Objetos miembro
| Nombre del miembro | Definición |
underlying_
(privado)
|
tupla de formateadores subyacentes de tipo
std::
tuple
<
std::
formatter
<
std::
remove_cvref_t
<
Ts
>
, CharT
>
...
>
( objeto miembro solo para exposición* ) |
separator_
(privado)
|
una cadena que representa el separador del resultado formateado de la tupla (por defecto
", "
)
( objeto miembro solo para exposición* ) |
opening-bracket_
(privado)
|
una cadena que representa el corchete de apertura del resultado formateado de la tupla (por defecto
"("
)
( objeto miembro solo para exposición* ) |
closing-bracket_
(privado)
|
una cadena que representa el corchete de cierre del resultado formateado de la tupla (por defecto
")"
)
( objeto miembro solo para exposición* ) |
Funciones miembro
|
set_separator
|
establece un separador específico para el resultado formateado de la tupla
(función miembro pública) |
|
set_brackets
|
establece corchetes de apertura y cierre específicos para el resultado formateado de la tupla
(función miembro pública) |
|
parse
|
analiza el especificador de formato según lo especificado por
tuple-format-spec
(función miembro pública) |
|
format
|
escribe la salida formateada de la tupla según lo especificado por
tuple-format-spec
(función miembro pública) |
std::formatter< pair-or-tuple >:: set_separator
|
constexpr
void
set_separator
(
std::
basic_string_view
<
CharT
>
sep
)
noexcept
;
|
||
Asigna
sep
a
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 ; |
||
Asigna
opening
y
closing
a
opening-bracket_
y
closing-bracket_
, respectivamente.
std::formatter< pair-or-tuple >:: parse
|
template
<
class
ParseContext
>
constexpr auto parse ( ParseContext & ctx ) - > ParseContext :: iterator ; |
||
Analiza los especificadores de formato como un tuple-format-spec y almacena los especificadores analizados en el objeto actual.
Si
tuple-type
o la opción
n
están presentes, los valores de
opening-bracket
,
closing-bracket
, y
separator
se modifican según sea necesario.
Para cada elemento
e
en
underlying_
, llama a
e.
parse
(
ctx
)
para analizar un
format-spec
vacío y, si
e.
set_debug_format
(
)
es una expresión válida, llama a
e.
set_debug_format
(
)
.
Retorna un iterador más allá del final del tuple-format-spec .
std::formatter< pair-or-tuple >:: format
|
template
<
class
FormatContext
>
FormatContext
::
iterator
|
||
/*maybe-const-pair-or-tuple*/ denota:
- const /*pair-or-tuple*/ , si ( std:: formattable < const Ts, CharT > && ... ) es true ,
- /*pair-or-tuple*/ en caso contrario.
Escribe lo siguiente en ctx. out ( ) según lo especificado por tuple-format-spec , en orden:
-
opening-bracket_, -
para cada índice
I
en
[ 0 ,sizeof... ( Ts )):
-
-
si
I
!
=
0
,
separator_, -
el resultado de escribir
std
::
get
<
I
>
(
elems
)
mediante
std
::
get
<
I
>
(
underlying_) , y
-
si
I
!
=
0
,
-
closing-bracket_.
Retorna un iterador más allá del final del rango de salida.
Informes de defectos
Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.
| DR | Aplicado a | Comportamiento publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 3892 | C++23 | el formato de tuplas anidadas era incorrecto | corregido |
Véase también
|
(C++20)
|
define las reglas de formato para un tipo dado
(plantilla de clase) |