Namespaces
Variants

std:: print

From cppreference.net
< cpp ‎ | io
C++
Input/output library
Print functions
Print functions
print
(C++23)
(C++23)
(C++23) (C++23)
(C++23) (C++23)
Definido en el encabezado <print>
template < class ... Args >
void print ( std:: format_string < Args... > fmt, Args && ... args ) ;
(1) (desde C++23)
template < class ... Args >

void print ( std:: FILE * stream,

std:: format_string < Args... > fmt, Args && ... args ) ;
(2) (desde C++23)

Formatee args de acuerdo con la cadena de formato fmt , e imprima el resultado en un flujo de salida.

1) Equivalente a std :: print ( stdout , fmt, std:: forward < Args > ( args ) ... ) .
2) Si la codificación literal ordinaria es UTF-8, equivalente a ( std :: enable_nonlocking_formatter_optimization < std:: remove_cvref_t < Args >> && ... )
? std:: vprint_unicode ( stream, fmt. str , std:: make_format_args ( args... ) )
: std :: vprint_unicode_buffered ( stream, fmt. str , std:: make_format_args ( args... ) ) ; .
De lo contrario, equivalente a ( std :: enable_nonlocking_formatter_optimization < std:: remove_cvref_t < Args >> && ... )
? std:: vprint_nonunicode ( stream, fmt. str , std:: make_format_args ( args... ) )
: std :: vprint_nonunicode_buffered ( stream, fmt. str , std:: make_format_args ( args... ) ) ; .

Si std:: formatter < Ti, char > no cumple con los requisitos de BasicFormatter para cualquier Ti en Args (como lo requiere std::make_format_args ), el comportamiento es indefinido.

Contenidos

Parámetros

stream - flujo de archivo de salida donde escribir
fmt -
un objeto que representa la cadena de formato. La cadena de formato consiste en
  • caracteres ordinarios (excepto { y } ), que se copian sin cambios a la salida,
  • secuencias de escape { { y } } , que se reemplazan con { y } respectivamente en la salida, y
  • campos de reemplazo.

Cada campo de reemplazo tiene el siguiente formato:

{ arg-id (opcional) } (1)
{ arg-id (opcional) : format-spec } (2)
1) campo de reemplazo sin especificación de formato
2) campo de reemplazo con especificación de formato
arg-id - especifica el índice del argumento en args cuyo valor se usará para el formato; si se omite, los argumentos se usan en orden.

Los arg-id s en una cadena de formato deben estar todos presentes o todos omitidos. Mezclar indexación manual y automática es un error.

format-spec - la especificación de formato definida por la especialización de std::formatter para el argumento correspondiente. No puede comenzar con } .

(desde C++23)
(desde C++26)
  • Para otros tipos formateables, la especificación de formato está determinada por especializaciones formatter definidas por el usuario.
args... - argumentos a formatear

Excepciones

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_print 202207L (C++23) Salida formateada
202403L (C++26)
(DR23) 		Salida formateada sin búfer
202406L (C++26)
(DR23) 		Habilitar salida formateada sin búfer para más tipos formateables
__cpp_lib_format 202207L (C++23) Exponer std::basic_format_string

Ejemplo

Ejecutar este código 
#include <cstdio>
#include <filesystem>
#include <print>
int main()
{
    std::print("{2} {1}{0}!\n", 23, "C++", "Hello");  // overload (1)
    const auto tmp{std::filesystem::temp_directory_path() / "test.txt"};
    if (std::FILE* stream{std::fopen(tmp.c_str(), "w")})
    {
        std::print(stream, "File: {}", tmp.string()); // overload (2)
        std::fclose(stream);
    }
}

Salida: 

Hello C++23!

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
P3107R5 C++23 solo se pueden realizar operaciones de impresión con búfer se pueden realizar operaciones de impresión sin búfer
P3235R3 C++23 los nombres de las funciones añadidas
por P3107R5 eran engañosos 		se cambiaron los nombres de las funciones

Véase también

(C++23)
igual que std::print excepto que cada impresión termina con una nueva línea adicional
(plantilla de función)
(C++23)
genera una representación formateada de los argumentos
(plantilla de función)
(C++20)
almacena la representación formateada de los argumentos en una nueva cadena
(plantilla de función)
(C++20)
escribe la representación formateada de sus argumentos a través de un iterador de salida
(plantilla de función)
(C++11)
imprime salida formateada a stdout , un flujo de archivo o un búfer
(función)