printf en C: cadenas de formato, especificadores e impresión de decimales

printf es la primera función que aprende todo programador de C y aquella cuyo manual la mayoría nunca lee del todo. Vale diez minutos, porque su cadena de formato es un pequeño lenguaje propio, y porque equivocarse en un especificador no es una errata: es comportamiento indefinido.

Vive en <stdio.h>, así que todo programa que la usa empieza con #include <stdio.h>.

El modelo de la cadena de formato

printf recorre la cadena de formato un carácter a la vez. Todo lo que no es un % se imprime exactamente como está escrito. Un % inicia una especificación de conversión, que se come el siguiente argumento y lo imprime en la forma pedida.

#include <stdio.h>

int main(void) {
    int    count = 5;
    double price = 2.5;
    char   grade = 'A';
    const char *name = "manzanas";

    printf("Texto simple, sin argumentos.\n");
    printf("%d %s cuestan $%.2f (calidad %c)\n", count, name, price, grade);
    return 0;
}

Los argumentos se emparejan con los especificadores estrictamente por posición: el primer % toma count, el segundo toma name, y así. printf no tiene forma de comprobar que pasaste lo que prometiste —no puede ver los tipos— así que la cadena de formato es un contrato que debes cumplir. Eso es lo que hace que valga la pena activar -Wall: GCC lee la cadena de formato literal en tiempo de compilación y avisa cuando un argumento no cuadra.

Nada obliga a un salto de línea. printf("Hola") deja el cursor después de la a, que es por lo que casi toda cadena de formato termina con \n.

Los especificadores que usas a diario

Cinco cubren casi todo el código:

#include <stdio.h>

int main(void) {
    int x = 42;

    printf("int      : %d\n", x);
    printf("double   : %f\n", 2.5);
    printf("cadena   : %s\n", "hola");
    printf("caracter : %c\n", 'A');
    printf("puntero  : %p\n", (void *)&x);
    printf("porciento: 100%%\n");
    return 0;
}

Dos reglas se esconden en ese fragmento. Un % literal se escribe %%; un % solitario al final de una cadena de formato es comportamiento indefinido. Y %p exige un void *, así que convierte el puntero; pasar un int * directamente es técnicamente indefinido aunque en la práctica imprima bien.

La tabla completa —cada especificador, cada modificador de longitud, la columna de scanf— está en la página de especificadores de formato. Esta página se queda con los que usas a mano.

Ancho, precisión y alineación

Entre el % y la letra puedes poner banderas, un ancho y una precisión. Así es como conviertes un bucle en una tabla.

#include <stdio.h>

int main(void) {
    printf("|%5d|\n", 42);        /* ancho 5, relleno antes del valor */
    printf("|%-5d|\n", 42);       /* bandera menos: relleno despues   */
    printf("|%05d|\n", 42);       /* bandera cero: rellena con ceros  */
    printf("|%+d|\n", 42);        /* bandera mas: muestra siempre el signo */
    printf("|%8.2f|\n", 3.14159); /* ancho 8, 2 digitos tras el punto */
    printf("|%-10s|\n", "ok");    /* las cadenas tambien se rellenan  */
    printf("|%.3s|\n", "cortame esto");  /* la precision en una cadena la corta */
    return 0;
}

El ancho es un mínimo, nunca un máximo: %3d con el valor 123456 imprime los seis dígitos. La precisión significa cosas distintas según el tipo: dígitos tras el punto decimal para %f, máximo de caracteres para %s, mínimo de dígitos para %d.

Ambos pueden suministrarse en tiempo de ejecución con un *, que lee un argumento int:

#include <stdio.h>

int main(void) {
    const char *names[] = {"Ada", "Grace", "Alan"};
    double scores[] = {92.5, 105.25, 87.0};
    int width = 10;

    printf("%-*s %8s\n", width, "NOMBRE", "PUNTAJE");
    for (int i = 0; i < 3; i++) {
        printf("%-*s %8.2f\n", width, names[i], scores[i]);
    }
    return 0;
}

Cambiar width recompone la tabla entera. Esta es la forma estándar de imprimir columnas alineadas en C, sin necesidad de ninguna función auxiliar de relleno.

Imprimir decimales con sensatez

%f sin precisión siempre imprime seis dígitos tras el punto, que rara vez es lo que alguien quiere:

#include <stdio.h>

int main(void) {
    double value = 1234.5;
    double tiny  = 0.000012345;
    double huge  = 123456789012.0;

    printf("%%f    : %f\n", value);
    printf("%%.2f  : %.2f\n", value);
    printf("%%.0f  : %.0f\n", value);
    printf("%%e    : %e\n", tiny);
    printf("%%g    : %g\n", tiny);
    printf("%%g    : %g\n", huge);
    printf("%%g    : %g\n", value);
    return 0;
}

Tres opciones, y una regla práctica para cada una:

• %.Nf para dinero, medidas y cualquier cosa con una cantidad natural de decimales. %.2f es lo que quieres para una moneda.
• %e para notación científica, siempre d.dddddde±dd.
• %g cuando no conoces la magnitud de antemano. Elige %f o %e, el que sea más corto, y quita los ceros finales: el valor por defecto más sensato para registrar un valor que no has visto.

Una trampa que conviene decir claramente: no existe %lf en printf. Los argumentos float se promocionan a double antes de que printf los vea, así que %f maneja ambos, y %lf solo tiene sentido en scanf, donde importa el tamaño del destino. (C99 sí acepta %lf en printf como sinónimo, pero el hábito de escribirlo lleva a escribir %f en scanf, que sí rompe las cosas.)

Enteros de otros anchos

%d es para int. Los tipos más grandes o sin signo necesitan un modificador de longitud, y equivocarse es comportamiento indefinido, no un error de redondeo:

#include <stdio.h>
#include <stdint.h>

int main(void) {
    long           big  = 3000000000L;
    unsigned int   u    = 4000000000u;
    size_t         len  = sizeof "hello";
    uint64_t       id   = 1234567890123456789ULL;

    printf("long     : %ld\n", big);
    printf("unsigned : %u\n", u);
    printf("size_t   : %zu\n", len);
    printf("uint64_t : %llu\n", (unsigned long long)id);

    printf("hex      : %x  HEX: %X  octal: %o\n", 255, 255, 8);
    return 0;
}

%zu para size_t es el que más se equivoca la gente: sizeof devuelve size_t, no int, así que printf("%d", sizeof x) es un error que da la casualidad de que funciona en sistemas de 32 bits y falla en los de 64.

El valor de retorno

printf devuelve la cantidad de caracteres que escribió, o un número negativo si falla. Normalmente se ignora, y en general está bien, pero es genuinamente útil cuando necesitas saber cuán ancha fue la salida:

#include <stdio.h>

int main(void) {
    int written = printf("Hola, mundo!\n");
    printf("esa llamada escribio %d caracteres\n", written);

    /* Util para subrayar algo cuyo ancho no conoces: */
    const char *title = "Informe";
    int n = printf("%s\n", title) - 1;   /* menos el salto de linea */
    for (int i = 0; i < n; i++) {
        putchar('=');
    }
    putchar('\n');
    return 0;
}

Las emparentadas sprintf y snprintf escriben en un búfer en lugar de en la pantalla, y devuelven la longitud que produjeron. Prefiere siempre snprintf, que toma el tamaño del búfer y no puede desbordarse:

#include <stdio.h>

int main(void) {
    char buffer[32];
    int n = snprintf(buffer, sizeof buffer, "%s saco %.1f", "Ada", 92.5);

    printf("[%s] (%d caracteres querian caber)\n", buffer, n);
    return 0;
}

snprintf devuelve la longitud que la cadena completa habría necesitado, así que un valor de retorno igual o mayor que el tamaño del búfer te dice que la salida se truncó.

La vulnerabilidad de cadena de formato

Este es el único problema de seguridad de printf, y es grave. Nunca pases como cadena de formato datos que no escribiste tú:

/* PELIGROSO: nunca hagas esto */
printf(user_input);

/* Correcto */
printf("%s", user_input);

Si user_input contiene %s, printf lee un argumento que nunca se pasó y sigue cualquier basura con forma de puntero que encuentre, normalmente reventando. Un %x repetido vuelca el contenido de la pila a la pantalla, lo que puede incluir contraseñas o claves. Y %n, que escribe el conteo de caracteres en un argumento, históricamente convirtió esto en corrupción arbitraria de memoria y ejecución remota de código.

La regla es absoluta y no cuesta nada: la cadena de formato es siempre un literal que escribiste tú. Todo lo variable entra como argumento. -Wformat-security de GCC señala el error, y está incluida en -Wall -Wextra.

Búfer: por qué a veces la salida aparece tarde

printf no escribe en la terminal de inmediato. La salida se almacena en un búfer, que se vacía cuando se llena, cuando aparece un salto de línea en una terminal o cuando el programa termina normalmente. Dos consecuencias:

• Un programa que revienta puede perder salida que "ya se imprimió". Si estás depurando con printf y el último mensaje nunca aparece, el fallo ocurrió después de esa línea, no antes. Agrega fflush(stdout) o manda la salida de depuración a stderr, que no usa búfer.
• fprintf(stderr, ...) es la forma correcta de imprimir errores. No usa búfer, y va a un flujo separado que los usuarios pueden redirigir de forma independiente de la salida normal.

#include <stdio.h>

int main(void) {
    printf("la salida normal va a stdout\n");
    fprintf(stderr, "los errores van a stderr\n");
    fflush(stdout);
    return 0;
}