Especificadores de formato em C: a referência completa de printf e scanf

Um especificador de formato diz ao printf como transformar um valor em texto, e ao scanf como transformar texto em um valor. É a única parte do C em que o compilador não consegue te ajudar por padrão - os tipos dos argumentos são invisíveis para a função - então esta página é a tabela de consulta.

A forma geral de uma especificação é:

%[flags][largura][.precisao][tamanho]conversao

Só o % e a letra de conversão são obrigatórios. %-8.2lf usa as cinco partes.

A tabela de conversões

#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;
}

Duas entradas merecem um aviso. %n escreve na memória em vez de imprimir, e é o mecanismo por trás da vulnerabilidade de string de formato - nunca deixe texto do usuário chegar a uma string de formato. E %p exige um void *; passar um int * diretamente é indefinido, mesmo que todo compilador real imprima o endereço mesmo assim.

Modificadores de tamanho

O modificador de tamanho fica entre a precisão e a letra de conversão, e diz qual é o tamanho real do argumento.

As conversões com sinal (d i) e as sem sinal (u x o) recebem tipos diferentes - %lu quer um unsigned long, não um long, e errar isso é comportamento indefinido, não um deslize cosmético.

E para as famílias de ponto flutuante e de caracteres:

As combinações que você de fato digita:

#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("hello");
    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 é o que você precisa memorizar. sizeof, strlen e todo tamanho da biblioteca padrão devolvem size_t, que tem 8 bytes em um sistema de 64 bits, enquanto int tem 4. printf("%d", strlen(s)) é um bug real que aparenta funcionar em algumas plataformas - use %zu.

Os modificadores hh e h existem principalmente para o scanf, onde o tamanho do destino importa. No printf um short é promovido a int antes da chamada, então %d o imprimiria corretamente de qualquer forma; %hd apenas documenta a intenção.

Tipos de largura fixa

Para tipos de <stdint.h> como int32_t, os especificadores portáveis são 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 nas letras certas para a sua plataforma, e literais de string adjacentes se concatenam, que é por que o formato está partido em três pedaços. É feio; a alternativa - converter para long long e usar %lld - costuma ser mais legível e é sempre correta.

Flags

As flags vêm logo depois do % e mudam a apresentação. Elas valem só para o 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;
}

As flags podem se combinar: %-+8.2f é largura mínima 8, duas casas decimais, sempre com sinal, preenchido depois do número. O - vence o 0 se você escrever os dois.

Largura e precisão

Largura é um tamanho mínimo de campo - a saída é preenchida até alcançá-lo, e nunca é truncada para caber nele. Precisão (depois de um ponto) significa coisas diferentes para cada família:

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* largura 10, 3 decimais */
    printf("|%.5d|\n",   42);          /* minimo de 5 digitos    */
    printf("|%.3s|\n",   "abcdefg");   /* no maximo 3 caracteres */
    printf("|%.0f|\n",   2.71828);     /* sem decimais           */
    printf("|%*d|\n",    8, 42);       /* largura vinda de um argumento */
    printf("|%.*f|\n",   3, 3.14159);  /* precisao vinda de um argumento */
    return 0;
}

Um * no lugar de qualquer um dos números o toma de um argumento int, lido antes do próprio valor. É assim que você monta tabelas cujas larguras de coluna são calculadas em tempo de execução.

No scanf a largura tem um papel diferente e bem mais importante: ela limita quanta entrada uma conversão vai consumir, que é a única coisa entre um %s e um estouro de buffer.

Onde printf e scanf divergem

Eles se parecem e discordam em quatro pontos. Cada um deles é uma fonte viva de bugs:

#include <stdio.h>

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

    printf("Digite um numero decimal e uma palavra: ");
    if (scanf("%lf %15s", &d, palavra) == 2) {   /* %lf e uma largura */
        printf("%.3f e \"%s\"\n", d, palavra);   /* %f e uma precisao */
    } else {
        printf("A entrada nao casou.\n");
    }
    return 0;
}

Experimente 2.5 ola. O formato que lê e o formato que imprime usam letras diferentes para o mesmo double, e o 15 em %15s limita a entrada a 15 caracteres mais o terminador - exatamente o tamanho de palavra.

O scanset do scanf

%[...] lê um conjunto de caracteres em vez de uma palavra delimitada por espaços. É a forma de ler uma linha inteira com scanf, embora o fgets continue sendo a ferramenta melhor:

#include <stdio.h>

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

    printf("Digite uma frase: ");
    if (scanf("%63[^\n]", linha) == 1) {     /* tudo ate uma quebra de linha */
        printf("Voce digitou: %s\n", linha);
    }
    return 0;
}

[^\n] significa "quaisquer caracteres exceto uma quebra de linha". %[0-9] leria só dígitos, %[abc] só essas três letras. Diferente do %s, um scanset não pula espaços em branco iniciais, então uma quebra de linha perdida no buffer faz com que ele não case com nada.

Errar é comportamento indefinido

O printf não enxerga o tipo real do seu argumento. Ele lê a quantidade de bytes que o especificador implica, interpretada como o especificador manda. Então um descasamento não é uma falha de formatação - é ler memória como a coisa errada:

printf("%d\n", 3.5);        /* imprime lixo: le os bits de um double como int */
printf("%s\n", 42);         /* trata 42 como um endereco - falha */
printf("%d\n", strlen(s));  /* size_t lido como int - errado em 64 bits */
printf("%f\n", 3);          /* int lido como double - lixo */

A defesa custa uma flag. Compile com -Wall e o GCC confere toda string de formato literal contra seus argumentos:

gcc -Wall -Wextra program.c -o program

Ele reporta cada uma das quatro linhas acima em tempo de compilação. Este é o aviso de maior valor em C, e ele está ligado por padrão no editor acima.

Para o lado prático de usar tudo isso - tabelas alinhadas, imprimir floats de forma legível, ler entrada sem o clássico bug da quebra de linha - veja printf e scanf.