Especificadores de formato en C: la referencia completa de printf y scanf

Un especificador de formato le dice a printf cómo convertir un valor en texto, y a scanf cómo convertir texto en un valor. Es la única parte de C donde el compilador no puede ayudarte por defecto —los tipos de los argumentos son invisibles para la función— así que esta página es la tabla con la que contrastar.

La forma general de una especificación es:

%[banderas][ancho][.precision][longitud]conversion

Solo el % y la letra de conversión son obligatorios. %-8.2lf usa las cinco partes.

La tabla de conversiones

#include <stdio.h>

int main(void) {
    int x = 255;

    printf("%%d  : %d\n", x);
    printf("%%u  : %u\n", x);
    printf("%%x  : %x\n", x);
    printf("%%X  : %X\n", x);
    printf("%%o  : %o\n", x);
    printf("%%c  : %c\n", 65);
    printf("%%s  : %s\n", "texto");
    printf("%%f  : %f\n", 3.5);
    printf("%%e  : %e\n", 3.5);
    printf("%%g  : %g\n", 3.5);
    printf("%%p  : %p\n", (void *)&x);
    return 0;
}

Dos entradas merecen una advertencia. %n escribe en memoria en lugar de imprimir, y es el mecanismo detrás de la vulnerabilidad de cadena de formato: nunca dejes que texto del usuario llegue a una cadena de formato. Y %p exige un void *; pasar un int * directamente es indefinido aunque todos los compiladores reales impriman la dirección igual.

Modificadores de longitud

El modificador de longitud va entre la precisión y la letra de conversión, y dice qué tan grande es realmente el argumento.

Las conversiones con signo (d i) y las sin signo (u x o) toman tipos distintos: %lu quiere un unsigned long, no un long, y equivocarse ahí es comportamiento indefinido, no un desliz cosmético.

Y para las familias de punto flotante y de caracteres:

Las combinaciones que de verdad escribes:

#include <stdio.h>
#include <string.h>

int main(void) {
    short              s   = -12;
    long               l   = 3000000000L;
    long long          ll  = 9000000000000000000LL;
    unsigned long      ul  = 4000000000UL;
    unsigned long long ull = 18000000000000000000ULL;
    size_t             len = strlen("hola");
    long double        ld  = 2.5L;

    printf("short              : %hd\n", s);
    printf("long               : %ld\n", l);
    printf("long long          : %lld\n", ll);
    printf("unsigned long      : %lu\n", ul);
    printf("unsigned long long : %llu\n", ull);
    printf("size_t             : %zu\n", len);
    printf("long double        : %Lf\n", ld);
    return 0;
}

%zu es el que hay que memorizar. sizeof, strlen y cualquier tamaño de la biblioteca estándar devuelven size_t, que ocupa 8 bytes en un sistema de 64 bits mientras que int ocupa 4. printf("%d", strlen(s)) es un error real que parece funcionar en algunas plataformas: usa %zu.

Los modificadores hh y h existen sobre todo para scanf, donde importa el tamaño del destino. En printf un short se promociona a int antes de la llamada, así que %d lo imprimiría bien de todos modos; %hd solo documenta la intención.

Tipos de ancho fijo

Para los tipos de <stdint.h> como int32_t, los especificadores portables son macros de <inttypes.h>:

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

int main(void) {
    int32_t  a = -2000000000;
    uint64_t b = 18000000000000000000ULL;

    printf("int32_t  : %" PRId32 "\n", a);
    printf("uint64_t : %" PRIu64 "\n", b);
    return 0;
}

PRId32 se expande a las letras correctas para tu plataforma, y los literales de cadena adyacentes se concatenan, que es por lo que el formato queda partido en tres piezas. Es feo; la alternativa —convertir a long long y usar %lld— suele ser más legible y siempre es correcta.

Banderas

Las banderas van inmediatamente después del % y cambian la presentación. Se aplican solo a printf.

#include <stdio.h>

int main(void) {
    printf("|%6d|\n",   42);
    printf("|%-6d|\n",  42);
    printf("|%06d|\n",  42);
    printf("|%+d|\n",   42);
    printf("|% d|\n",   42);
    printf("|%#x|\n",  255);
    printf("|%#o|\n",   64);
    printf("|%#.0f|\n", 3.0);
    return 0;
}

Las banderas se combinan: %-+8.2f es ancho mínimo 8, dos decimales, siempre con signo, rellenado después del número. - gana sobre 0 si escribes ambas.

Ancho y precisión

El ancho es un tamaño mínimo de campo: la salida se rellena hasta alcanzarlo, y nunca se trunca para caber en él. La precisión (después de un punto) significa algo distinto para cada familia:

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* ancho 10, 3 decimales */
    printf("|%.5d|\n",   42);          /* minimo 5 digitos      */
    printf("|%.3s|\n",   "abcdefg");   /* como mucho 3 caracteres */
    printf("|%.0f|\n",   2.71828);     /* sin decimales         */
    printf("|%*d|\n",    8, 42);       /* ancho tomado de un argumento */
    printf("|%.*f|\n",   3, 3.14159);  /* precision tomada de un argumento */
    return 0;
}

Un * en lugar de cualquiera de los dos números lo toma de un argumento int, leído antes del valor en sí. Así se construyen tablas cuyos anchos de columna se calculan en tiempo de ejecución.

En scanf el ancho tiene un trabajo distinto y mucho más importante: limita cuánta entrada consume una conversión, que es lo único que se interpone entre %s y un desbordamiento de búfer.

Dónde difieren printf y scanf

Se parecen y no coinciden en cuatro puntos. Cada uno de ellos es una fuente viva de errores:

#include <stdio.h>

int main(void) {
    double d;
    char   word[16];

    printf("Escribe un numero decimal y una palabra: ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf y un ancho */
        printf("%.3f y \"%s\"\n", d, word);   /* %f y una precision */
    } else {
        printf("La entrada no coincidio.\n");
    }
    return 0;
}

Prueba con 2.5 hola. El formato que lo lee y el que lo imprime usan letras distintas para el mismo double, y el 15 de %15s limita la entrada a 15 caracteres más el terminador, exactamente el tamaño de word.

El conjunto de caracteres de scanf

%[...] lee un conjunto de caracteres en vez de una palabra delimitada por espacios. Es la forma de leer una línea completa con scanf, aunque fgets sigue siendo la mejor herramienta:

#include <stdio.h>

int main(void) {
    char line[64];

    printf("Escribe una frase: ");
    if (scanf("%63[^\n]", line) == 1) {     /* todo hasta un salto de linea */
        printf("Escribiste: %s\n", line);
    }
    return 0;
}

[^\n] significa "cualquier carácter excepto un salto de línea". %[0-9] leería solo dígitos, %[abc] solo esas tres letras. A diferencia de %s, un conjunto de caracteres no salta los espacios iniciales, así que un salto de línea suelto en el búfer hace que no coincida con nada.

Equivocarse es comportamiento indefinido

printf no puede ver el tipo real de tu argumento. Lee la cantidad de bytes que implica el especificador, interpretados como el especificador diga. Así que un desajuste no es un fallo de formato: es leer memoria como lo que no es.

printf("%d\n", 3.5);        /* imprime basura: lee los bits de un double como int */
printf("%s\n", 42);         /* trata 42 como una direccion: revienta */
printf("%d\n", strlen(s));  /* size_t leido como int: mal en 64 bits */
printf("%f\n", 3);          /* int leido como double: basura */

La defensa cuesta una bandera. Compila con -Wall y GCC contrasta cada cadena de formato literal con sus argumentos:

gcc -Wall -Wextra program.c -o program

Reporta cada una de las cuatro líneas de arriba en tiempo de compilación. Es el aviso de mayor valor de todo C, y está activado por defecto en el editor de arriba.

Para el lado práctico de usarlos —tablas alineadas, imprimir decimales de forma legible, leer entrada sin el clásico error del salto de línea— mira printf y scanf.