print(std::ostream)

Definido en el archivo de encabezado `<ostream>`
template< class... Args > void print( std::ostream& os, std::format_string<Args...> fmt, Args&&... args );		(desde C++23)

Da formato a args de acuerdo a la cadena de formato fmt, e inserta el resultado en el flujo os.

Si la codificación literal ordinaria es UTF-8, es equivalente a:

std::vprint_unicode(os, fmt.get(), std::make_format_args(args...));. De lo contrario, es equivalente a
std::vprint_nonunicode(os, fmt.get(), std::make_format_args(args...));.

El comportamiento es indefinido si std::formatter<Ti, char> no cumple con los requerimientos BasicFormatter para cualquier Ti en Args (según lo requiere std::make_format_args).

Parámetros

os - Flujo de salida al cual insertarle los datos

fmt

-

[edit]

Un objeto que representa la cadena de formato. La cadena de formato consiste en:

caracteres ordinarios (excepto { y }), que se copian sin cambiarse 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:

un carácter { introductorio;
(opcional) arg-id, un número no negativo;
(opcional) dos puntos (:) seguido de una especificación de formato;
un carácter } final.

arg-id especifica el índice del argumento en args cuyo valor se usará para formatear; si se omite arg-id, los argumentos se usan en orden. Los arg-ids en una cadena de formato tienen que estar presentes o todos deben de omitirse. Mezclar la indexación manual y automática es un error.

La especificación de formato se define por la especialización de std::formatter del argumento correspondiente.

Para los tipos básicos y los tipos de cadena estándar, la especificación de formato se interpreta como la especificación de formato estándar.
Para los tipos chrono, la especificación de formato se interpreta como especificación de formato chrono.

Para los tipos rango, la especificación de formato se interpreta como especificación de formato para rangos.
Para std::pair y std::tuple, la especificación de formato se interpreta como especificación de formato para tuplas.
Para std::thread::id y std::stacktrace_entry, véase la especificación de formato para identificador de hilos y la especificación de formato para una entrada del listado de pila.
Para std::basic_stacktrace, no se permite un especificador de formato.

(desde C++23)

Para std::filesystem::path, véase la especificación de formato para ruta de acceso.

(desde C++26)

Para los otros tipos formateables, la especificación de formato se determina por especializaciones de formatter definidas por el usuario.

args... - Argumentos a ser formateados

Valor de retorno

(ninguno)

Excepciones

std::bad_alloc en errores de asignación.
Propaga cualquier excepción lanzada por cualquier formatter, p.e. std::format_error, sin importar el valor de os.exceptions() y sin activar std::ios_base::badbit en el estado de error de os.
Puede lanzar std::ios_base::failure causada por os.setstate(ios_base::badbit) el cual es llamado si una inserción a os falla.

Notas

Macro de prueba de característica	Valor	Estándar	Comentario
`__cpp_lib_print`	`202207L`	(C++23)	Salida formateada
`__cpp_lib_format`	`202207L`	(C++23)	Exponiendo std::basic_format_string

Ejemplo

Ejecuta este código

#include <array>
#include <cctype>
#include <cstdio>
#include <format>
#include <numbers>
#include <ranges>
#include <sstream>

int main()
{
    std::array<char, 24> buf;
    std::format_to(buf.begin(), "{:.15f}", std::numbers::sqrt2);

    unsigned num{}, sum{};

    auto v = buf
           | std::views::filter(isdigit)
           | std::views::transform([](char x) { return x - '0'; })
           | std::views::take_while([&sum](char) { return sum < 42; });

    for (auto n : v)
        sum += n, ++num;

    std::stringstream stream;

    std::print(stream,
        "√2 = {}...\n"
        "La suma de los primeros {} dígitos es {}{}",
        std::numbers::sqrt2, num, sum, '.'
    );

    std::puts(stream.str().data());
}

Salida:

√2 = 1.4142135623730951...
La suma de los primeros 13 dígitos es 42.

Véase también

println(std::ostream) (C++23)	Genera la representación formateada de los argumentos con la adición del caracter de nueva línea `'\n'` al final (plantilla de función) [editar]
print (C++23)	Imprime en stdout, o en un flujo de archivo usando la representación formateada de los argumentos (plantilla de función) [editar]
format (C++20)	Almacena una representación formateada de los argumentos en una cadena nueva. (plantilla de función) [editar]

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones