print(std::ostream)

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de E/S

Manipuladores de E/S

E/S estilo C

Búferes

basic_streambuf

basic_filebuf

basic_stringbuf

strstreambuf (en desuso en C++98)

basic_syncbuf (C++20)

Flujos

Abstracciones

ios_base

basic_ios

basic_istream

basic_ostream

basic_iostream

E/S de archivos

basic_ifstream

basic_ofstream

basic_fstream

E/S de cadenas

basic_istringstream

basic_ostringstream

basic_stringstream

E/S de arrays

istrstream (en desuso en C++98)

ostrstream (en desuso en C++98)

strstream (en desuso en C++98)

Salida sincronizada

basic_osyncstream (C++20)

Tipos

streamoff

streamsize

fpos

Interfaz de categoría de error

iostream_category (C++11)

io_errc (C++11)

 

std::basic_ostream

Objetos globales
coutwcout	cerrwcerr	clogwclog
Funciones miembro
basic_ostream::basic_ostream
basic_ostream::~basic_ostream
basic_ostream::operator= (C++11)
Salida formateada
basic_ostream::operator<<
Salida no formateada
basic_ostream::put
basic_ostream::write
Posicionamiento
basic_ostream::tellp
basic_ostream::seekp
Misceláneas
basic_ostream::flush
basic_ostream::swap (C++11)
Member classes
basic_ostream::sentry
Funciones no miembro
operator<<(std::basic_ostream)
print(std::ostream) (C++23)
println(std::ostream) (C++23)
vprint_unicode(std::ostream) (C++23)
vprint_nonunicode(std::ostream) (C++23)

 

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	-	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 ios_base::badbit en el estado de error de os.
• Puede lanzar 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)
print (C++23)	Imprime en stdout, o en un flujo de archivo usando la representación formateada de los argumentos (plantilla de función)
format (C++20)	Almacena una representación formateada de los argumentos en una cadena nueva. (plantilla de función)