C printf e scanf

Esta é a página de consulta rápida do printf ("print formatted", imprimir formatado) e do scanf ("scan formatted", ler formatado). Aqui estão, em tabelas, todos os formatos, ajustes e armadilhas. Para aprender com calma, passo a passo, veja as aulas Saída com printf, Formatos do printf e Entrada com scanf.

Todas as saídas foram produzidas de verdade: no gcc 15.2 da máquina da Ana (Linux de 64 bits, pasta ~/c/ref, comando gcc -std=c23 -Wall -Wextra) e no editor do guia (Clang em WebAssembly). Quando os dois diferem, a tabela diz.

Atalhos: Anatomia de um formato · Especificadores · Modificadores de tamanho · Flags · Largura e precisão · O * · A família printf · scanf · printf × scanf · Erros comuns · Experimente

Anatomia de um formato

Cada lacuna do printf começa com % e termina com uma letra (o especificador). Entre os dois podem vir, nesta ordem, quatro ajustes opcionais:

%  [flags]  [largura]  [.precisão]  [tamanho]  especificador
%     -        10          .2           l            f        →  %-10.2lf

flags

Zero ou mais destes: - (alinhar à esquerda), + (sempre mostrar o sinal), espaço, # (forma alternativa), 0 (completar com zeros). Tabela.

largura

Número mínimo de caracteres que a lacuna ocupa. Se o valor é maior, ela cresce: a largura nunca corta. * = "a largura vem do próximo argumento".

.precisão

Um ponto seguido de um número. O sentido muda com o tipo: casas decimais no %f, algarismos significativos no %g, dígitos mínimos no %d, caracteres máximos no %s. .* = vem do próximo argumento.

tamanho

Diz o tamanho do valor: hh h l ll j z t L (e wN no C23). Tabela.

especificador

A letra que diz o tipo e a forma de mostrar: d, f, s… Tabela.

Especificadores do printf

Medidos com este programa (os colchetes mostram onde cada lacuna começa e termina):

#include <stdio.h>

int main(void) {
    int n = 255;
    double x = 3.14159;
    printf("[%d] [%i] [%u]\n", -42, -42, 42u);
    printf("[%o] [%x] [%X] [%#o] [%#x] [%#X]\n", n, n, n, n, n, n);
    printf("[%f] [%F] [%e] [%E]\n", x, x, x, x);
    printf("[%g] [%G] [%g] [%g]\n", x, 0.00001234, 1e20, 100000.0);
    printf("[%a] [%A]\n", 1.0, 0.5);
    printf("[%c] [%s] [%%]\n", 'A', "Ana");
    printf("[%b] [%#b] [%B]\n", 10u, 10u, 5u);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra esp.c -o esp
$ ./esp
[-42] [-42] [42]
[377] [ff] [FF] [0377] [0xff] [0XFF]
[3.141590] [3.141590] [3.141590e+00] [3.141590E+00]
[3.14159] [1.234E-05] [1e+20] [100000]
[0x1p+0] [0X1P-1]
[A] [Ana] [%]
[1010] [0b1010] [101]

• %d e %i são iguais no printf. No scanf não: %i entende 0x1F como hexadecimal e 017 como octal (veja a tabela do scanf).
• %g troca para a notação científica quando o expoente é menor que −4 ou maior ou igual à precisão (6, sem precisão): 100000.0 sai 100000, mas 1e20 sai 1e+20.
• %f serve para float e double: ao passar por printf, todo float é convertido em double. Por isso, no printf, %lf é igual a %f. No scanf é diferente (veja por quê).
• %p espera um void *: o jeito certo é printf("%p\n", (void *)&idade).
• %n é perigoso: um texto vindo do usuário usado como formato pode escrever na memória com ele. É por isso que nunca se escreve printf(texto) (veja Erros comuns).

Modificadores de tamanho

O modificador vem logo antes da letra e diz o tamanho do valor. Sem ele, %d espera um int. Com l, um long; com ll, um long long; e assim por diante.

O modificador também vale para o %n: %hhn guarda num signed char, %ln num long, e assim por diante.

Support for formatting long double values is currently disabled.
To enable it, add -lc-printscan-long-double to the link command.
Abortado (imagem do núcleo gravada)

Tipos de tamanho fixo: inttypes.h

Para int64_t, uint8_t etc. (aula stdint.h), o formato certo muda de sistema para sistema (int64_t é long no Linux de 64 bits e long long no editor). A solução portátil são as macros do <inttypes.h>, que viram o texto certo e se "colam" ao resto do formato:

#include <inttypes.h>
int64_t populacao = 123456789012;
printf("População: %" PRId64 "\n", populacao);   // vira "%ld" no gcc e "%lld" no editor

Flags

#include <stdio.h>

int main(void) {
    printf("[%5d] [%-5d] [%05d] [%+d] [% d] [%+d]\n", 42, 42, 42, 42, 42, -42);
    printf("[%8.3f] [%-8.2f] [%08.2f] [%+.1f] [%.0f] [%#.0f]\n", 3.14159, 3.14159, 3.14159, 3.14159, 2.5, 2.0);
    printf("[%.5d] [%8.5d] [%.0d] [%.3s] [%10.3s] [%-10s]\n", 42, 42, 0, "Banana", "Banana", "Ana");
    printf("[%.3e] [%.3g] [%#g] [%g]\n", 1234.5678, 1234.5678, 1.5, 1.5);
    int larg = 6, prec = 2;
    printf("[%*d] [%-*d] [%.*f] [%*.*f]\n", larg, 7, larg, 7, prec, 3.14159, larg, prec, 3.14159);
    printf("[%*d]\n", -6, 7);
    printf("[%#x] [%#o] [%#x]\n", 0, 0, 255);
    printf("[%-+6d] [%+05d]\n", 7, 7);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra flags.c -o flags
$ ./flags
[   42] [42   ] [00042] [+42] [ 42] [-42]
[   3.142] [3.14    ] [00003.14] [+3.1] [2] [2.]
[00042] [   00042] [] [Ban] [       Ban] [Ana       ]
[1.235e+03] [1.23e+03] [1.50000] [1.5]
[     7] [7     ] [3.14] [  3.14]
[7     ]
[0] [0] [0xff]
[+7    ] [+0007]

A saída do editor é idêntica, caractere por caractere.

As flags podem ser combinadas, em qualquer ordem: %-+6d → [+7 ], %+05d → [+0007].

Largura e precisão

• O arredondamento é "para o par" no empate exato: printf("%.0f", 2.5) mostra 2, não 3 (e 3.5 mostra 4). Nos outros casos, arredonda para o mais próximo.
• A largura conta bytes, não letras: em UTF-8, ã e ç ocupam 2 bytes, e uma coluna com %-10s sai torta. Veja Acentos e UTF-8.

O *: largura e precisão em variáveis

Um * no lugar do número diz "pegue a largura (ou a precisão) do próximo argumento, que é um int". Os argumentos vêm na ordem em que aparecem: largura, precisão, valor.

Atenção: o argumento do * tem de ser int. Um sizeof ou strlen (que são size_t) precisa de conversão: printf("%.*s", (int)strlen(t), t).

A família printf e o valor de retorno

#include <stdio.h>

int main(void) {
    int n = printf("Olá, Ana!\n");
    printf("printf devolveu %d\n", n);
    char curto[8];
    int precisa = snprintf(curto, sizeof curto, "Total: R$ %.2f", 1234.5);
    printf("[%s] precisava de %d caracteres\n", curto, precisa);
    int x;
    int r = scanf("%d", &x);
    printf("scanf devolveu %d (EOF = %d)\n", r, EOF);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra retorno.c -o retorno
retorno.c: In function ‘main’:
retorno.c:7:58: warning: ‘Total: R$ ’ directive output truncated writing 10 bytes into a region of size 8 [-Wformat-truncation=]
    7 |     int precisa = snprintf(curto, sizeof curto, "Total: R$ %.2f", 1234.5);
      |                                                  ~~~~~~~~^~
retorno.c:7:19: note: ‘snprintf’ output 18 bytes into a destination of size 8
    7 |     int precisa = snprintf(curto, sizeof curto, "Total: R$ %.2f", 1234.5);
      |                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$ ./retorno < /dev/null                       « entrada vazia: o scanf encontra o fim do arquivo
Olá, Ana!
printf devolveu 11
[Total: ] precisava de 17 caracteres
scanf devolveu -1 (EOF = -1)

• "Olá, Ana!\n" tem 10 letras, mas o printf devolveu 11: ele conta bytes, e o á ocupa 2.
• O snprintf cortou o texto em 7 caracteres + '\0' e avisou, pelo retorno, que precisava de 17. O gcc percebeu já na compilação (-Wformat-truncation, que vem com o -Wall); o Clang do editor não avisa.

scanf: a tabela

O scanf usa quase as mesmas letras, mas ao contrário: em vez de receber valores, recebe endereços de variáveis (por isso o &) e as preenche com o que o usuário digitou. Aula: Entrada com scanf.

O que mais pode ir no formato

O valor de retorno

Todos esses casos num programa só:

#include <stdio.h>

int main(void) {
    int idade = 0;
    double altura = 0.0;
    char nome[20] = "";
    char cidade[40] = "";
    char letra = '?';
    int lidos = scanf("%d %lf", &idade, &altura);
    printf("lidos=%d idade=%d altura=%.2f\n", lidos, idade, altura);
    lidos = scanf(" %c", &letra);
    printf("lidos=%d letra=%c\n", lidos, letra);
    lidos = scanf("%19s", nome);
    printf("lidos=%d nome=%s\n", lidos, nome);
    lidos = scanf(" %39[^\n]", cidade);
    printf("lidos=%d cidade=%s\n", lidos, cidade);
    int d, m, a;
    lidos = scanf("%d/%d/%d", &d, &m, &a);
    printf("lidos=%d data=%02d/%02d/%d\n", lidos, d, m, a);
    int h = 0, n = 0;
    lidos = scanf("%i %*d %x%n", &h, &d, &n);
    printf("lidos=%d h=%d d=%d n=%d\n", lidos, h, d, n);
    lidos = scanf("%d", &idade);
    printf("lidos=%d\n", lidos);
    lidos = scanf("%d", &idade);
    printf("lidos=%d\n", lidos);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra leitura.c -o leitura
$ printf '29 1.65\nA\nAna\nSão Paulo - SP\n17/10/2026\n0x1F 99 ff\nabc\n' | ./leitura
lidos=2 idade=29 altura=1.65
lidos=1 letra=A
lidos=1 nome=Ana
lidos=1 cidade=São Paulo - SP
lidos=3 data=17/10/2026
lidos=2 h=31 d=255 n=11
lidos=0
lidos=0

• %i leu 0x1F como 31; o %*d leu o 99 e jogou fora (por isso lidos=2, e não 3); o %x leu ff = 255.
• n=11: o Enter que sobrou da linha anterior (1) mais 0x1F 99 ff (10).
• As duas últimas leituras devolvem 0: o abc não é um número e fica na entrada, travando todas as leituras de %d seguintes. É por isso que um laço com scanf que não confere o retorno pode rodar para sempre. Solução: Validar a Entrada.

printf × scanf: as diferenças que confundem

Erros comuns

Este programa reúne os enganos mais frequentes. O -Wall pega quase todos:

#include <stdio.h>

int main(void) {
    int idade = 29;
    double preco = 4.5;
    char texto[20] = "100% certo";
    printf("%d\n", preco);
    printf("%f\n", idade);
    printf("%d %d\n", idade);
    printf("%lu\n", sizeof(int));
    printf("%s\n", 'A');
    printf(texto);
    printf("\n50%\n");
    scanf("%d", idade);
    scanf("%f", &preco);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra errado.c -o errado
errado.c: In function ‘main’:
errado.c:7:14: warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘double’ [-Wformat=]
    7 |     printf("%d\n", preco);
      |             ~^     ~~~~~
      |              |     |
      |              int   double
      |             %f
errado.c:8:14: warning: format ‘%f’ expects argument of type ‘double’, but argument 2 has type ‘int’ [-Wformat=]
    8 |     printf("%f\n", idade);
      |             ~^     ~~~~~
      |              |     |
      |              |     int
      |              double
      |             %d
errado.c:9:17: warning: format ‘%d’ expects a matching ‘int’ argument [-Wformat=]
    9 |     printf("%d %d\n", idade);
      |                ~^
      |                 |
      |                 int
errado.c:11:14: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int’ [-Wformat=]
   11 |     printf("%s\n", 'A');
      |             ~^     ~~~
      |              |     |
      |              |     int
      |              char *
      |             %d
errado.c:12:12: warning: format not a string literal and no format arguments [-Wformat-security]
   12 |     printf(texto);
      |            ^~~~~
errado.c:13:18: warning: unknown conversion type character ‘\x0a’ in format [-Wformat=]
   13 |     printf("\n50%\n");
      |                  ^~
errado.c:14:13: warning: format ‘%d’ expects argument of type ‘int *’, but argument 2 has type ‘int’ [-Wformat=]
   14 |     scanf("%d", idade);
      |            ~^   ~~~~~
      |             |   |
      |             |   int
      |             int *
errado.c:15:13: warning: format ‘%f’ expects argument of type ‘float *’, but argument 2 has type ‘double *’ [-Wformat=]
   15 |     scanf("%f", &preco);
      |            ~^   ~~~~~~
      |             |   |
      |             |   double *
      |             float *
      |            %lf

A mesma coisa, aviso por aviso, com a versão do Clang (o compilador do editor):

Erros que o compilador não pega

#include <stdio.h>

int main(void) {
    int qtd = 0;
    char tam = '?';
    char nome[20] = "";
    printf("Quantidade: ");
    scanf("%d", &qtd);
    printf("Tamanho (P/M/G): ");
    scanf("%c", &tam);
    printf("\nqtd=%d tam=%d\n", qtd, tam);
    printf("Nome completo: ");
    scanf("%19s", nome);
    printf("nome=[%s]\n", nome);
    return 0;
}

$ ./enter
Quantidade: 3                                 « a Ana digita 3 e Enter
Tamanho (P/M/G):
qtd=3 tam=10                                  « nem esperou: o %c leu o Enter (código 10)
Nome completo: M                              « a Ana digita M, achando que é o tamanho
nome=[M]

Experimente

Um laboratório de formatos: troque os formatos e os valores e veja o resultado. Os colchetes mostram onde cada lacuna começa e termina, assim dá para ver os espaços.

#include <stdio.h>

int main(void) {
    int qtd = 7;
    double preco = 12.9;
    const char *item = "Caderno";

    printf("[%d] [%5d] [%-5d] [%05d] [%+d]\n", qtd, qtd, qtd, qtd, qtd);
    printf("[%f] [%.2f] [%8.2f] [%-8.1f] [%e] [%g]\n", preco, preco, preco, preco, preco, preco);
    printf("[%s] [%10s] [%-10s] [%.3s]\n", item, item, item, item);
    printf("[%x] [%X] [%#x] [%o] [%c]\n", 255, 255, 255, 8, 'A');

    int largura = 12;
    printf("[%*s] [%-*s]\n", largura, item, largura, item);
    printf("%zu bytes num double; 100%% pronto\n", sizeof preco);
    return 0;
}

#include <stdio.h>

int main(void) {
    double altura = 0.0;
    printf("Sua altura: ");
    if (scanf("%f", &altura) != 1) {
        printf("Isso não é um número.\n");
        return 1;
    }
    printf("Altura: %.2f m\n", altura);
    return 0;
}

#include <stdio.h>

int main(void) {
    double altura = 0.0;
    printf("Sua altura: ");
    if (scanf("%lf", &altura) != 1) {
        printf("Isso não é um número.\n");
        return 1;
    }
    printf("Altura: %.2f m\n", altura);
    return 0;
}

Resumo

• Formato: %[flags][largura][.precisão][tamanho]letra, nesta ordem. Exemplo: %-10.2lf.
• Letras: d i u o x X (inteiros), f e g a (ponto flutuante), c, s, p, %%. %b (binário, C23) só funciona no gcc.
• Tamanhos: hh (char), h (short), l (long), ll (long long), z (size_t), t (ptrdiff_t), j (intmax_t), L (long double). Para int64_t, PRId64.
• Flags: - esquerda, + sinal, espaço, 0 zeros, # forma alternativa. * tira largura ou precisão de um argumento int.
• No scanf: endereços (&), %lf para double, " %c" para pular o Enter, %19s com largura, %[^\n] para a linha; confira o retorno (campos lidos, 0 ou EOF).
• Compile com -Wall: ele pega formato errado, & esquecido e printf(texto).