Namespaces
Variants

    printf, fprintf, sprintf, snprintf, printf_s, fprintf_s, sprintf_s, snprintf_s

    De es.cppreference.net
    < c | io
     
    C
     
    Entrada/salida de archivos
    Tipos y objetos
            
    Funciones
    Acceso a archivos
    (C11)
    (C11)  
    (C95)
    Entrada/salida sin formato
    (C95)(C95)
    (C95)
    (C95)(C95)
    (C95)
    (C95)
    (C95)
    (C95)

    Entrada formateada
    (C99)(C99)(C99)(C11)(C11)(C11)
    (C99)(C99)(C99)(C11)(C11)(C11)  
    Entrada/salida directa
    Salida formateada
    Posicionamiento de archivos
    Manejo de errores
    Operaciones en archivos
     
    Definido en el encabezado <stdio.h> 
    int printf( const char* format, ... );
    		(1) (hasta C99) 
    int printf( const char* restrict format, ... );
    		(desde C99) 
    int fprintf( FILE* stream, const char* format, ... );
    		(2) (hasta C99) 
    int fprintf( FILE* restrict stream, const char* restrict format, ... );
    		(desde C99) 
    int sprintf( char* buffer, const char* format, ... );
    		(3) (hasta C99) 
    int sprintf( char* restrict buffer, const char* restrict format, ... );
    		(desde C99) 
    int snprintf( char* restrict buffer, size_t bufsz,
              const char* restrict format, ... );
    		(4) (desde C99) 
    int printf_s( const char* restrict format, ... );
    		(5) (desde C11) 
    int fprintf_s( FILE* restrict stream, const char* restrict format, ... );
    		(6) (desde C11) 
    int sprintf_s( char* restrict buffer, rsize_t bufsz,
               const char* restrict format, ... );
    		(7) (desde C11) 
    int snprintf_s( char* restrict buffer, rsize_t bufsz,
                const char* restrict format, ... );
    		(8) (desde C11)

    Carga los datos de las ubicaciones dadas, los convierte a sus equivalentes de cadena de caracteres y escribe los resultados en una variedad de destinos/flujos:

    1) Escribe los resultados en el flujo de salida stdout.
    2) Escribe los resultados en el flujo de salida stream.
    3) Escribe los resultados en una cadena de caracteres buffer. El comportamiento no está definido si la cadena a escribir (más el carácter nulo terminador) excede el tamaño del arreglo apuntado por buffer.
    4) Escribe los resultados en una cadena de caracteres buffer. Se escriben como máximo bufsz - 1 caracteres. La cadena de caracteres resultante terminará con un carácter nulo, a menos que bufsz sea cero. Si bufsz es cero, no se escribe nada y buffer puede ser un puntero nulo, sin embargo, el valor de retorno (número de bytes que se habrían escrito sin incluir el terminador nulo) aún se calcula y se devuelve.
    5-8) Igual que (1-4), excepto que los siguientes errores se detectan en tiempo de ejecución y llaman a la función manejador de restricciones instalada actualmente:
    • el especificador de conversión %n está presente en format
    • cualquiera de los argumentos correspondientes a %s es un puntero nulo
    • stream o format o buffer es un puntero nulo
    • bufsz es cero o mayor que RSIZE_MAX
    • ocurren errores de codificación en cualquier especificador de conversión de cadena y carácter
    • (solo para sprintf_s), la cadena a almacenar en buffer (incluyendo el nulo final) excedería bufsz.
    Como con todas las funciones con verificación de límites, printf_s, fprintf_s, sprintf_s, y snprintf_s solo se garantiza que estén disponibles si __STDC_LIB_EXT1__ está definido por la implementación y si el usuario define __STDC_WANT_LIB_EXT1__ como la constante entera 1 antes de incluir <stdio.h>.

    Parámetros

    stream - flujo de archivo de salida al que escribir
    buffer - puntero a una cadena de caracteres a la que escribir
    bufsz - hasta bufsz - 1 caracteres se pueden escribir, más el terminador nulo
    format - puntero a una cadena de bytes terminada en nulo que especifica cómo interpretar los datos
    ... - argumentos que especifican datos a imprimir. Si algún argumento después de las promociones de argumentos predeterminadas no es del tipo esperado por la especificación de conversión correspondiente (el tipo esperado es el tipo promocionado o un tipo compatible del tipo promocionado), o si hay menos argumentos de los requeridos por format, el comportamiento no está definido. Si hay más argumentos de los requeridos por format, los argumentos adicionales se evalúan y se ignoran.

    La cadena format consiste en caracteres de bytes ordinarios (excepto %), que se copian sin cambios al flujo de salida, y especificaciones de conversión. Cada especificación de conversión tiene el siguiente formato:

    • carácter % introductorio.
    • (opcional) uno o más indicadores que modifican el comportamiento de la conversión:
    • -: el resultado de la conversión se alinea a la izquierda dentro del campo (por defecto está alineado a la derecha).
    • +: el signo de las conversiones con signo siempre se antepone al resultado de la conversión (por defecto el resultado está precedido por un signo menos solo cuando es negativo).
    • espacio: si el resultado de una conversión con signo no comienza con un carácter de signo, o está vacío, se antepone un espacio al resultado. Se ignora si el indicador + está presente.
    • #: se realiza la forma alternativa de la conversión. Consulte la tabla a continuación para conocer los efectos exactos, de lo contrario el comportamiento no está definido.
    • 0: para conversiones de números enteros y de punto flotante, se utilizan ceros a la izquierda para rellenar el campo en lugar de caracteres espacio. Para números enteros se ignora si la precisión se especifica explícitamente. Para otras conversiones, el uso de este indicador resulta en comportamiento no definido. Se ignora si el indicador - está presente.
    • (opcional) valor entero o * que especifica el ancho mínimo del campo. El resultado se rellena con caracteres espacio (por defecto), si es necesario, a la izquierda cuando está alineado a la derecha, o a la derecha si está alineado a la izquierda. En el caso de que se use *, el ancho se especifica mediante un argumento adicional de tipo int, que aparece antes del argumento a convertir y el argumento que proporciona la precisión si se proporciona uno. Si el valor del argumento es negativo, resulta en el indicador - especificado y ancho de campo positivo (Nota: Este es el ancho mínimo: El valor nunca se trunca.).
    • (opcional) . seguido de un número entero o *, o ninguno, que especifica la precisión de la conversión. En el caso de que se use *, la precisión se especifica mediante un argumento adicional de tipo int, que aparece antes del argumento a convertir, pero después del argumento que proporciona el ancho mínimo del campo si se proporciona uno. Si el valor de este argumento es negativo, se ignora. Si no se usa ni un número ni *, la precisión se toma como cero. Consulte la tabla a continuación para conocer los efectos exactos de la precisión.
    • (opcional) modificador de longitud que especifica el tamaño del argumento (en combinación con el especificador de formato de conversión, especifica el tipo del argumento correspondiente).
    • especificador de formato de conversión.

    Los siguientes especificadores de formato están disponibles:

    Conversión
    Especificador     		Explicación Tipo de
    Argumento Esperado
    Modificador de Longitud→ hh h ninguno l ll j z t L
    Solo disponible desde C99→ Sí Sí Sí Sí Sí
    % Escribe el literal %. La especificación de conversión completa debe ser %%. N/A N/A N/A N/A N/A N/A N/A N/A N/A
    c

    Escribe un solo carácter.

    • El argumento se convierte primero a unsigned char.
    • Si se usa el modificador l, el argumento se convierte primero a una cadena de caracteres como si fuera con %ls con un argumento wchar_t[2].
    		 N/A N/A
    int
    wint_t
    		 N/A N/A N/A N/A N/A
    s

    Escribe una cadena de caracteres.

    • El argumento debe ser un puntero al elemento inicial de un arreglo de caracteres.
    • Precisión especifica el número máximo de bytes a escribir. Si no se especifica Precisión, escribe cada byte hasta el primer terminador nulo sin incluirlo.
    • Si se usa el especificador l, el argumento debe ser un puntero al elemento inicial de un arreglo de wchar_t, que se convierte a un arreglo de char como si fuera mediante una llamada a wcrtomb con estado de conversión inicializado a cero.
    		 N/A N/A
    char*
    wchar_t*
    		 N/A N/A N/A N/A N/A
    d
    i

    Convierte un entero con signo a representación decimal [-]dddd.

    • Precisión especifica el número mínimo de dígitos que aparecerán. La precisión predeterminada es 1.
    • Si tanto el valor convertido como la precisión son 0, la conversión no produce caracteres.
    • Para el modificador z, el tipo de argumento esperado es la versión con signo de size_t.
    signed char
    short
    int
    long
    long long
    intmax_t
    ※
    ptrdiff_t
    		 N/A
    b
    B (opcional)

    (C23)

    Convierte un entero sin signo a representación binaria bbbb.

    • Precisión especifica el número mínimo de dígitos que aparecerán. La precisión predeterminada es 1.
    • Si tanto el valor convertido como la precisión son 0, la conversión no produce caracteres.
    • En la implementación alternativa 0b o 0B se antepone a los resultados si el valor convertido es distinto de cero.
    unsigned char
    unsigned short
    unsigned int
    unsigned long
    unsigned long long
    uintmax_t
    size_t
    versión sin signo de ptrdiff_t
    		 N/A
    o

    Convierte un entero sin signo a representación octal oooo.

    • Precisión especifica el número mínimo de dígitos que aparecerán. La precisión predeterminada es 1.
    • Si tanto el valor convertido como la precisión son 0, la conversión no produce caracteres.
    • En la implementación alternativa la precisión se incrementa si es necesario, para escribir un cero a la izquierda. En ese caso, si tanto el valor convertido como la precisión son 0, se escribe un único 0.
    		 N/A
    x
    X

    Convierte un entero sin signo a representación hexadecimal hhhh.

    • Para la conversión x se usan las letras abcdef.
    • Para la conversión X se usan las letras ABCDEF.
    • Precisión especifica el número mínimo de dígitos que aparecerán. La precisión predeterminada es 1.
    • Si tanto el valor convertido como la precisión son 0, la conversión no produce caracteres.
    • En la implementación alternativa 0x o 0X se antepone a los resultados si el valor convertido es distinto de cero.
    		 N/A
    u

    Convierte un entero sin signo a representación decimal dddd.

    • Precisión especifica el número mínimo de dígitos que aparecerán.
    • La precisión predeterminada es 1.
    • Si tanto el valor convertido como la precisión son 0, la conversión no produce caracteres.
    		 N/A
    f
    F (C99)

    Convierte un número de punto flotante a la notación decimal en el estilo [-]ddd.ddd.

    • Precisión especifica el número exacto de dígitos que aparecerán después del carácter del punto decimal.
    • La precisión predeterminada es 6.
    • En la implementación alternativa se escribe el carácter del punto decimal incluso si no le siguen dígitos.
    • Para el estilo de conversión de infinito y no es un número, consulte notas.
    		 N/A N/A
    double
    double (C99)
    		 N/A N/A N/A N/A
    long double
    e
    E

    Convierte un número de punto flotante a la notación de exponente decimal.

    • Para el estilo de conversión e se usa [-]d.ddd e±dd.
    • Para el estilo de conversión E se usa [-]d.ddd E±dd.
    • El exponente contiene al menos dos dígitos, se usan más dígitos solo si es necesario.
    • Si el valor es 0, el exponente también es 0.
    • Precisión especifica el número exacto de dígitos que aparecerán después del carácter del punto decimal.
    • La precisión predeterminada es 6.
    • En la implementación alternativa se escribe el carácter del punto decimal incluso si no le siguen dígitos.
    • Para el estilo de conversión de infinito y no es un número, consulte notas.
    		 N/A N/A N/A N/A N/A N/A
    a
    A

    (C99)

    Convierte un número de punto flotante a la notación de exponente hexadecimal.

    • Para el estilo de conversión a se usa [-] 0xh.hhh p±d.
    • Para el estilo de conversión A se usa [-] 0Xh.hhh P±d.
    • El primer dígito hexadecimal no es 0 si el argumento es un valor de punto flotante normalizado.
    • Si el valor es 0, el exponente también es 0.
    • Precisión especifica el número exacto de dígitos que aparecerán después del carácter del punto hexadecimal.
    • La precisión predeterminada es suficiente para la representación exacta del valor.
    • En la implementación alternativa se escribe el carácter del punto decimal incluso si no le siguen dígitos.
    • Para el estilo de conversión de infinito y no es un número, consulte notas.
    		 N/A N/A N/A N/A N/A N/A
    g
    G

    Convierte un número de punto flotante a notación decimal o de exponente decimal dependiendo del valor y la precisión.

    • Para el estilo de conversión g se realizará la conversión con estilo e o f.
    • Para el estilo de conversión G se realizará la conversión con estilo E o f(hasta C99)F(desde C99).
    • Sea P igual a la precisión si es distinta de cero, 6 si no se especifica la precisión, o 1 si la precisión es 0. Entonces, si una conversión con estilo E tendría un exponente de X:
      • Si P > X ≥ −4, la conversión es con estilo f o F(desde C99) y precisión P − 1 − X.
      • De lo contrario, la conversión es con estilo e o E y precisión P − 1.
    • A menos que se solicite la representación alternativa, se eliminan los ceros finales; también se elimina el carácter del punto decimal si no queda parte fraccionaria.
    • Para el estilo de conversión de infinito y no es un número, consulte notas.
    		 N/A N/A N/A N/A N/A N/A
    n

    Devuelve el número de caracteres escritos hasta ahora por esta llamada a la función.

    • El resultado se escribe en el valor al que apunta el argumento.
    • La especificación no puede contener ningún indicador, ancho de campo o precisión.
    • Para el modificador z, el tipo de argumento esperado es S*, donde S es la versión con signo de size_t.
    signed char*
    short*
    int*
    long*
    long long*
    intmax_t*
    ※
     ptrdiff_t* 
    		 N/A
    p

    Escribe una secuencia de caracteres definida por la implementación que define un puntero.

    		N/A N/A
    void*
    		 N/A N/A N/A N/A N/A N/A
    Notas

    Las funciones de conversión de punto flotante convierten infinito a inf o infinity. Cuál se usa está definido por la implementación.

    No es un número se convierte a nan o nan(char_sequence). Cuál se usa está definido por la implementación.

    Las conversiones F, E, G, A producen INF, INFINITY, NAN en su lugar.

    El especificador de conversión utilizado para imprimir char, unsigned char, signed char, short y unsigned short espera tipos promocionados de las promociones de argumentos predeterminadas, pero antes de imprimir su valor se convertirá a char, unsigned char, signed char, short y unsigned short. Es seguro pasar valores de estos tipos debido a la promoción que tiene lugar cuando se llama a una función variádica.

    Las especificaciones de conversión correctas para los tipos de caracteres de ancho fijo (int8_t, etc.) se definen en el encabezado <inttypes.h> (aunque PRIdMAX, PRIuMAX, etc. son sinónimos de %jd, %ju, etc.).

    El especificador de conversión de escritura en memoria %n es un objetivo común de explotaciones de seguridad donde las cadenas de formato dependen de la entrada del usuario y no es compatible con la familia de funciones con verificación de límites printf_s (desde C11).

    Hay un punto de secuencia después de la acción de cada especificador de conversión; esto permite almacenar múltiples resultados %n en la misma variable o, como caso extremo, imprimir una cadena modificada por un %n anterior dentro de la misma llamada.

    Si una especificación de conversión no es válida, el comportamiento no está definido.

    Valor de retorno

    1,2) número de caracteres transmitidos al flujo de salida o valor negativo si ocurrió un error de salida o un error de codificación (para especificadores de conversión de cadena y carácter).
    3) número de caracteres escritos en buffer (sin contar el carácter nulo terminador), o un valor negativo si ocurrió un error de codificación (para especificadores de conversión de cadena y carácter).
    4) número de caracteres (sin incluir el carácter nulo terminador) que se habrían escrito en buffer si se hubiera ignorado bufsz, o un valor negativo si ocurrió un error de codificación (para especificadores de conversión de cadena y carácter).
    5,6) número de caracteres transmitidos al flujo de salida o valor negativo si ocurrió un error de salida, un error de violación de restricciones en tiempo de ejecución o un error de codificación.
    7) número de caracteres escritos en buffer, sin contar el carácter nulo (que siempre se escribe siempre que buffer no sea un puntero nulo y bufsz no sea cero ni mayor que RSIZE_MAX), o cero en violaciones de restricciones en tiempo de ejecución, y valor negativo en errores de codificación.
    8) número de caracteres sin incluir el carácter nulo terminador (que siempre se escribe siempre que buffer no sea un puntero nulo y bufsz no sea cero ni mayor que RSIZE_MAX), que se habrían escrito en buffer si se hubiera ignorado bufsz, o un valor negativo si ocurrió una violación de restricciones en tiempo de ejecución o un error de codificación.

    Notas

    El estándar C y POSIX especifican que el comportamiento de sprintf y sus variantes no está definido cuando un argumento se superpone con el búfer de destino. Ejemplo: 

    sprintf(dst, "%s and %s", dst, t); // <- broken: undefined behavior

    POSIX especifica que errno se establece en caso de error. También especifica especificaciones de conversión adicionales, especialmente el soporte para el reordenamiento de argumentos (n$ inmediatamente después de % indica el argumento nésimo).

    Llamar a snprintf con cero bufsz y puntero nulo para buffer es útil para determinar el tamaño de búfer necesario para contener la salida: 

    const char fmt[] = "sqrt(2) = %f";
int sz = snprintf(NULL, 0, fmt, sqrt(2));
char buf[sz + 1]; // note +1 for terminating null byte
snprintf(buf, sizeof buf, fmt, sqrt(2));

    snprintf_s, al igual que snprintf, pero a diferencia de sprintf_s, truncará la salida para que quepa en bufsz - 1.

    Ejemplo

    Ejecutar este código
    #include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const char* s = "Hello";
    printf("Strings:\n"); // same as puts("Strings");
    printf(" padding:\n");
    printf("\t[%10s]\n", s);
    printf("\t[%-10s]\n", s);
    printf("\t[%*s]\n", 10, s);
    printf(" truncating:\n");
    printf("\t%.4s\n", s);
    printf("\t%.*s\n", 3, s);

    printf("Characters:\t%c %%\n", 'A');

    printf("Integers:\n");
    printf("\tDecimal:\t%i %d %.6i %i %.0i %+i %i\n",
                         1, 2,   3, 0,   0,  4,-4);
    printf("\tHexadecimal:\t%x %x %X %#x\n", 5, 10, 10, 6);
    printf("\tOctal:\t\t%o %#o %#o\n", 10, 10, 4);

    printf("Floating-point:\n");
    printf("\tRounding:\t%f %.0f %.32f\n", 1.5, 1.5, 1.3);
    printf("\tPadding:\t%05.2f %.2f %5.2f\n", 1.5, 1.5, 1.5);
    printf("\tScientific:\t%E %e\n", 1.5, 1.5);
    printf("\tHexadecimal:\t%a %A\n", 1.5, 1.5);
    printf("\tSpecial values:\t0/0=%g 1/0=%g\n", 0.0 / 0.0, 1.0 / 0.0);

    printf("Fixed-width types:\n");
    printf("\tLargest 32-bit value is %" PRIu32 " or %#" PRIx32 "\n",
                                     UINT32_MAX,     UINT32_MAX );
}

    Posible salida: 

    Strings:
 padding:
        [     Hello]
        [Hello     ]
        [     Hello]
 truncating:
        Hell
        Hel
Characters:     A %
Integers:
        Decimal:        1 2 000003 0  +4 -4
        Hexadecimal:    5 a A 0x6
        Octal:          12 012 04
Floating-point:
        Rounding:       1.500000 2 1.30000000000000004440892098500626
        Padding:        01.50 1.50  1.50
        Scientific:     1.500000E+00 1.500000e+00
        Hexadecimal:    0x1.8p+0 0X1.8P+0
        Special values: 0/0=-nan 1/0=inf
Fixed-width types:
        Largest 32-bit value is 4294967295 or 0xffffffff

    Referencias

    • Estándar C23 (ISO/IEC 9899:2024):
    • 7.21.6.1 La función fprintf (p: TBD)
    • 7.21.6.3 La función printf (p: TBD)
    • 7.21.6.5 La función snprintf (p: TBD)
    • 7.21.6.6 La función sprintf (p: TBD)
    • K.3.5.3.1 La función fprintf_s (p: TBD)
    • K.3.5.3.3 La función printf_s (p: TBD)
    • K.3.5.3.5 La función snprintf_s (p: TBD)
    • K.3.5.3.6 La función sprintf_s (p: TBD)
    • Estándar C17 (ISO/IEC 9899:2018):
    • 7.21.6.1 La función fprintf (p: 225-230)
    • 7.21.6.3 La función printf (p: 236)
    • 7.21.6.5 La función snprintf (p: 237)
    • 7.21.6.6 La función sprintf (p: 237)
    • K.3.5.3.1 La función fprintf_s (p: 430)
    • K.3.5.3.3 La función printf_s (p: 432)
    • K.3.5.3.5 La función snprintf_s (p: 432-433)
    • K.3.5.3.6 La función sprintf_s (p: 433)
    • Estándar C11 (ISO/IEC 9899:2011):
    • 7.21.6.1 La función fprintf (p: 309-316)
    • 7.21.6.3 La función printf (p: 324)
    • 7.21.6.5 La función snprintf (p: 325)
    • 7.21.6.6 La función sprintf (p: 325-326)
    • K.3.5.3.1 La función fprintf_s (p: 591)
    • K.3.5.3.3 La función printf_s (p: 593-594)
    • K.3.5.3.5 La función snprintf_s (p: 594-595)
    • K.3.5.3.6 La función sprintf_s (p: 595-596)
    • Estándar C99 (ISO/IEC 9899:1999):
    • 7.19.6.1 La función fprintf (p: 274-282)
    • 7.19.6.3 La función printf (p: 290)
    • 7.19.6.5 La función snprintf (p: 290-291)
    • 7.19.6.6 La función sprintf (p: 291)
    • Estándar C89/C90 (ISO/IEC 9899:1990):
    • 4.9.6.1 La función fprintf
    • 4.9.6.3 La función printf
    • 4.9.6.5 La función sprintf

    Véase también

    (C95)(C95)(C95)(C11)(C11)(C11)(C11)
    		 imprime salida formateada de caracteres anchos en stdout, un flujo de archivo o un búfer
    (función)
    (C99)(C11)(C11)(C11)(C11)
    		 imprime salida formateada en stdout, un flujo de archivo o un búfer
    usando una lista de argumentos variable
    (función)
    		escribe una cadena de caracteres en un flujo de archivo
    (función)
    (C11)(C11)(C11)
    		 lee entrada formateada desde stdin, un flujo de archivo o un búfer
    (función)
    Documentación de C++ para printf, fprintf, sprintf, snprintf