Namespaces
Variants

std:: println

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

void println ( std:: FILE * stream,

std:: format_string < Args... > fmt, Args && ... args ) ;
(2) (desde C++23)
void println ( ) ;
(3) (desde C++26)
void println ( std:: FILE * stream ) ;
(4) (desde C++26)

Formatee args de acuerdo con la cadena de formato fmt con ' \n ' añadido (lo que significa que cada salida termina con una nueva línea), e imprima el resultado a un flujo.

1) Equivalente a std :: println ( stdout , fmt, std:: forward < Args > ( args ) ... ) .
2) Equivalente a realizar las siguientes operaciones:

std:: print ( stream, "{} \n " , std:: format ( fmt, std:: forward < Args > ( args ) ... ) ) ;

(hasta C++26)

std:: print ( stream, std:: runtime_format ( std:: string ( fmt. get ( ) ) + ' \n ' ) ,
std:: forward < Args > ( args ) ... )

(desde C++26)
3) Equivalente a std :: println ( stdout ) .
4) Equivalente a std:: print ( stream, " \n " ) .

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 } .

(since C++23)
(since 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

Aunque las sobrecargas ( 3,4 ) se añaden en C++26, todas las implementaciones conocidas las hacen disponibles en modo C++23.

Macro de prueba de características Valor Std Característica
__cpp_lib_print 202207L (C++23) Salida formateada
202403L (C++26) Salida formateada sin búfer [1]
__cpp_lib_format 202207L (C++23) Exponiendo std::basic_format_string
  1. ↑ Aunque P3107R5 se acepta como un DR, std::runtime_format solo está disponible a partir de C++26. Como resultado, la resolución no puede aplicarse en C++23.

Ejemplo

Ejecutar este código 
#include <print>
int main()
{
    // Cada llamada a std::println termina con nueva línea
    std::println("Please"); // sobrecarga (1)
    std::println("enter"); // (1)
    std::print("pass");
    std::print("word");
    std::println(); // (3); válido desde C++26; mismo efecto que std::print("\n"); 
}

Salida: 

Please
enter
password

Véase también

(C++23)
imprime en stdout o un flujo de archivo usando representación formateada de los argumentos
(plantilla de función)
(C++23)
genera representación formateada de los argumentos con ' \n ' añadido
(plantilla de función)
(C++20)
almacena representación formateada de los argumentos en una nueva cadena
(plantilla de función)
(C++11)
imprime salida formateada en stdout , un flujo de archivo o un búfer
(función)