printf em C: strings de formato, especificadores e como imprimir floats

printf é a primeira função que todo programador C aprende e aquela cujo manual a maioria nunca leu até o fim. Vale dez minutos, porque a string de formato dele é uma pequena linguagem à parte - e porque errar um especificador não é um erro de digitação, é comportamento indefinido.

Ele mora em <stdio.h>, então todo programa que o usa começa com #include <stdio.h>.

O modelo da string de formato

O printf percorre a string de formato um caractere por vez. Tudo que não é % é impresso exatamente como escrito. Um % inicia uma especificação de conversão, que consome o próximo argumento e o imprime no formato pedido.

#include <stdio.h>

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

    printf("Texto puro, sem argumentos.\n");
    printf("%d %s custam R$%.2f (nota %c)\n", count, name, price, grade);
    return 0;
}

Os argumentos são casados com os especificadores estritamente por posição: o primeiro % pega count, o segundo pega name, e assim por diante. O printf não tem como conferir se você passou o que prometeu - ele não enxerga os tipos - então a string de formato é um contrato que cabe a você cumprir. É isso que torna o -Wall digno de ser ligado: o GCC lê a string de formato literal em tempo de compilação e avisa quando um argumento não bate.

Nada força uma quebra de linha. printf("Ola") deixa o cursor depois do a, e é por isso que quase toda string de formato termina com \n.

Os especificadores do dia a dia

Cinco deles cobrem a maior parte do código:

#include <stdio.h>

int main(void) {
    int x = 42;

    printf("int      : %d\n", x);
    printf("double   : %f\n", 2.5);
    printf("string   : %s\n", "ola");
    printf("char     : %c\n", 'A');
    printf("ponteiro : %p\n", (void *)&x);
    printf("porcento : 100%%\n");
    return 0;
}

Duas regras se escondem nesse trecho. Um % literal se escreve %% - um % sozinho no fim de uma string de formato é comportamento indefinido. E %p exige um void *, então converta o ponteiro; passar um int * direto é tecnicamente indefinido, mesmo que na prática imprima bem.

A tabela completa - todos os especificadores, todos os modificadores de comprimento, a coluna do scanf - está na página de especificadores de formato. Esta página fica nos que você usa toda hora.

Largura, precisão e alinhamento

Entre o % e a letra você pode colocar flags, uma largura e uma precisão. É assim que um laço vira uma tabela.

#include <stdio.h>

int main(void) {
    printf("|%5d|\n", 42);        /* largura 5, espacos antes do valor */
    printf("|%-5d|\n", 42);       /* flag menos: espacos depois do valor */
    printf("|%05d|\n", 42);       /* flag zero: preenche com zeros       */
    printf("|%+d|\n", 42);        /* flag mais: sempre mostra o sinal    */
    printf("|%8.2f|\n", 3.14159); /* largura 8, 2 digitos apos o ponto   */
    printf("|%-10s|\n", "ok");    /* strings tambem sao preenchidas      */
    printf("|%.3s|\n", "corte-me aqui");  /* precisao numa string a corta */
    return 0;
}

A largura é um mínimo, nunca um máximo: %3d com o valor 123456 imprime os seis dígitos. A precisão significa coisas diferentes por tipo - dígitos depois do ponto decimal para %f, máximo de caracteres para %s, mínimo de dígitos para %d.

As duas podem ser fornecidas em tempo de execução com um *, que lê um 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, "NOME", "NOTA");
    for (int i = 0; i < 3; i++) {
        printf("%-*s %8.2f\n", width, names[i], scores[i]);
    }
    return 0;
}

Mudar width reorganiza a tabela inteira. Essa é a maneira padrão de imprimir colunas alinhadas em C - sem precisar de nenhuma função auxiliar de preenchimento de string.

Imprimindo floats com bom senso

%f sem precisão sempre imprime seis dígitos depois do ponto, o que raramente é o que alguém quer:

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

Três escolhas, e uma regra prática para cada uma:

• %.Nf para dinheiro, medidas, qualquer coisa com um número natural de casas decimais. %.2f é o que você quer para moeda.
• %e para notação científica, sempre d.dddddde±dd.
• %g quando você não conhece a ordem de grandeza de antemão. Ele escolhe %f ou %e, o que for mais curto, e tira os zeros à direita - o padrão mais sensato para registrar um valor que você ainda não viu.

Uma armadilha que vale dizer com todas as letras: não existe %lf no printf. Argumentos float são promovidos a double antes de o printf sequer vê-los, então %f dá conta dos dois, e %lf só faz sentido no scanf, onde o tamanho do destino importa. (O C99 até aceita %lf no printf como sinônimo, mas o hábito de escrevê-lo leva as pessoas a escrever %f no scanf, o que aí sim quebra de verdade.)

Inteiros de outros tamanhos

%d é para int. Tipos maiores ou sem sinal precisam de um modificador de comprimento, e errar isso é comportamento indefinido, não um erro de arredondamento:

#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 é o que as pessoas mais erram - sizeof devolve size_t, não int, então printf("%d", sizeof x) é um bug que por acaso funciona em sistemas de 32 bits e se comporta mal nos de 64.

O valor de retorno

O printf devolve o número de caracteres que escreveu, ou um número negativo em caso de falha. Ele costuma ser ignorado, e na maior parte do tempo tudo bem - mas é genuinamente útil quando você precisa saber qual foi a largura da saída:

#include <stdio.h>

int main(void) {
    int written = printf("Ola, mundo!\n");
    printf("aquela chamada escreveu %d caracteres\n", written);

    /* Util para sublinhar algo cuja largura voce nao sabe: */
    const char *title = "Relatorio";
    int n = printf("%s\n", title) - 1;   /* menos a quebra de linha */
    for (int i = 0; i < n; i++) {
        putchar('=');
    }
    putchar('\n');
    return 0;
}

As parentes sprintf e snprintf escrevem num buffer em vez de na tela, e devolvem o comprimento que produziram. Prefira sempre o snprintf, que recebe o tamanho do buffer e não pode estourá-lo:

#include <stdio.h>

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

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

O snprintf devolve o comprimento que a string completa teria precisado, então um valor de retorno igual ou maior que o tamanho do buffer avisa que a saída foi truncada.

A vulnerabilidade de format string

Esse é o único problema de segurança do printf, e ele é grave. Nunca passe como string de formato dados que você não escreveu:

/* PERIGOSO - nunca faca isso */
printf(entrada_do_usuario);

/* Correto */
printf("%s", entrada_do_usuario);

Se entrada_do_usuario contiver %s, o printf lê um argumento que nunca foi passado e segue qualquer lixo em forma de ponteiro que encontrar, geralmente travando. %x repetido despeja o conteúdo da pilha na tela, o que pode incluir senhas ou chaves. E %n, que escreve a contagem de caracteres num argumento, historicamente transformou isso em corrupção arbitrária de memória e execução remota de código.

A regra é absoluta e não custa nada: a string de formato é sempre um literal escrito por você. Tudo que for variável entra como argumento. O -Wformat-security do GCC sinaliza o erro, e ele já vem incluído em -Wall -Wextra.

Bufferização: por que a saída às vezes aparece atrasada

O printf não escreve no terminal imediatamente. A saída é bufferizada - descarregada quando o buffer enche, quando aparece uma quebra de linha num terminal, ou quando o programa termina normalmente. Duas consequências:

• Um programa que trava pode perder saída que "já foi impressa". Se você está depurando com printf e a última mensagem nunca aparece, o travamento aconteceu depois daquela linha, não antes. Acrescente fflush(stdout) ou mande a saída de depuração para stderr, que não é bufferizada.
• fprintf(stderr, ...) é a forma certa de imprimir erros. Ela não é bufferizada e vai para um fluxo separado que os usuários podem redirecionar independentemente da saída normal.

#include <stdio.h>

int main(void) {
    printf("a saida normal vai para stdout\n");
    fprintf(stderr, "os erros vao para stderr\n");
    fflush(stdout);
    return 0;
}