A biblioteca padrão do C: um mapa dos cabeçalhos que vale conhecer

O C como linguagem é minúsculo - tipos, operadores, controle de fluxo, funções, ponteiros. Ele não sabe imprimir, ler um arquivo, comparar uma string nem alocar memória. Tudo isso é a biblioteca padrão: um conjunto de cabeçalhos que toda implementação conforme entrega.

Esta página é um mapa. Cada seção diz para que serve um cabeçalho, mostra um exemplo curto e funcional, e aponta para a página mais completa onde existir uma.

stdio.h - entrada e saída

O cabeçalho que você inclui primeiro em quase todo programa. Ele guarda printf e scanf, o tipo FILE e as funções de arquivo, e as funções de entrada orientadas a linha, mais seguras.

#include <stdio.h>

int main(void) {
    printf("Formatado: %d %s %.2f %c\n", 42, "texto", 3.14159, 'X');

    /* fputs escreve sem interpretar especificadores de formato */
    fputs("Saida simples, sem formatacao\n", stdout);

    /* stderr e um fluxo separado para diagnosticos */
    fprintf(stderr, "Isto vai para a saida de erro padrao\n");

    /* putchar escreve um unico caractere */
    for (char c = 'a'; c <= 'e'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

O essencial: printf, fprintf, sprintf, snprintf para saída; scanf, fscanf, sscanf, fgets, getchar para entrada; fopen, fclose, fread, fwrite, fseek para arquivos. A cobertura mais profunda está em printf, scanf e manipulação de arquivos.

Uma regra que vale carregar: nunca use gets(). Ele não tem como saber o tamanho do seu buffer e foi removido da norma no C11. fgets(buf, sizeof buf, stdin) é o substituto.

stdlib.h - utilitários gerais

O pega-tudo: memória, conversões, aleatoriedade, controle de processo, ordenação.

#include <stdio.h>
#include <stdlib.h>

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

int main(void) {
    /* string para numero */
    printf("atoi(\"123\")     = %d\n", atoi("123"));
    printf("strtol(\"ff\", 16) = %ld\n", strtol("ff", NULL, 16));
    printf("atof(\"3.5\")     = %.2f\n", atof("3.5"));

    /* memoria dinamica */
    int *nums = malloc(5 * sizeof *nums);
    if (nums == NULL) {
        return 1;
    }
    int seed_values[] = {50, 10, 40, 20, 30};
    for (int i = 0; i < 5; i++) {
        nums[i] = seed_values[i];
    }

    /* qsort ordena qualquer coisa, dada uma funcao de comparacao */
    qsort(nums, 5, sizeof *nums, compare_ints);
    for (int i = 0; i < 5; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    free(nums);
    return 0;
}

Destaques: malloc, calloc, realloc, free (veja memória dinâmica); atoi, atof, strtol, strtod para conversões - prefira a família strto*, que consegue reportar falha onde o atoi silenciosamente devolve 0; rand e srand (veja números aleatórios); exit, abort, getenv, system; e qsort/bsearch.

string.h - strings e blocos de memória

Strings em C são arrays de char terminados em '\0', e toda operação sobre elas é uma chamada de função.

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

int main(void) {
    char dest[64] = "Ola";

    printf("strlen  : %zu\n", strlen(dest));

    strcat(dest, ", mundo");
    printf("strcat  : %s\n", dest);

    printf("strcmp  : %d\n", strcmp("abacate", "banana"));
    printf("strchr  : %s\n", strchr(dest, 'm'));
    printf("strstr  : %s\n", strstr(dest, "mundo"));

    char copy[64];
    strcpy(copy, dest);
    printf("strcpy  : %s\n", copy);

    /* as funcoes mem* trabalham com bytes crus, nao so com texto */
    char block[10];
    memset(block, '-', 9);
    block[9] = '\0';
    printf("memset  : %s\n", block);
    return 0;
}

Dois hábitos impedem que esse cabeçalho vire uma fonte de estouros de buffer: sempre saiba o tamanho do destino, e lembre que strcmp devolve 0 para igualdade - if (strcmp(a, b)) é verdadeiro quando as strings diferem. Funções de string cobre em detalhe os padrões mais seguros com strncpy/snprintf.

math.h - matemática

sqrt, pow, fabs, floor, ceil, round, fmod, as famílias trigonométrica e logarítmica, INFINITY e NAN.

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("sqrt(2)     = %.6f\n", sqrt(2.0));
    printf("pow(2, 10)  = %.0f\n", pow(2.0, 10.0));
    printf("ceil(4.1)   = %.0f\n", ceil(4.1));
    printf("fabs(-9.5)  = %.1f\n", fabs(-9.5));
    return 0;
}

Esse é o único cabeçalho que pode precisar de uma flag de ligação: no Linux, acrescente -lm no fim do comando de compilação, ou o ligador reporta "undefined reference to sqrt". Passeio completo em funções matemáticas.

time.h - relógios e datas

#include <stdio.h>
#include <time.h>

int main(void) {
    time_t now = time(NULL);
    printf("Segundos desde 1970: %ld\n", (long) now);
    printf("Hora local: %s", ctime(&now));

    struct tm *lt = localtime(&now);
    printf("Ano: %d, mes: %d, dia: %d\n",
           lt->tm_year + 1900, lt->tm_mon + 1, lt->tm_mday);

    char buf[64];
    strftime(buf, sizeof buf, "%Y-%m-%d %H:%M:%S", lt);
    printf("Formatado: %s\n", buf);

    /* clock() mede o tempo de processador usado por este programa */
    clock_t start = clock();
    volatile long sum = 0;
    for (long i = 0; i < 3000000L; i++) {
        sum += i;
    }
    double secs = (double)(clock() - start) / CLOCKS_PER_SEC;
    printf("O laco levou %.4f segundos de CPU\n", secs);
    return 0;
}

Os dois deslocamentos em struct tm pegam todo mundo: tm_year conta a partir de 1900, e tm_mon começa em 0. time(NULL) também é a semente usual para o srand.

ctype.h - classificação de caracteres

Pequeno, e mais útil do que parece. Cada função recebe um caractere e responde a uma pergunta de sim ou não, ou converte maiúsculas/minúsculas.

#include <stdio.h>
#include <ctype.h>

int main(void) {
    const char *text = "Coddy C17, lancado!";

    int letters = 0, digits = 0, spaces = 0, punct = 0;
    for (const char *p = text; *p != '\0'; p++) {
        unsigned char c = (unsigned char) *p;
        if (isalpha(c))      letters++;
        else if (isdigit(c)) digits++;
        else if (isspace(c)) spaces++;
        else if (ispunct(c)) punct++;
    }
    printf("letras=%d digitos=%d espacos=%d pontuacao=%d\n",
           letters, digits, spaces, punct);

    printf("Maiusculas: ");
    for (const char *p = text; *p != '\0'; p++) {
        putchar(toupper((unsigned char) *p));
    }
    printf("\n");
    return 0;
}

O conjunto completo: isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, além de toupper e tolower.

Repare na conversão (unsigned char). Essas funções são definidas para valores representáveis como unsigned char mais EOF; um char puro tem sinal na maioria dos sistemas, então um byte acima de 127 chega como número negativo e a chamada vira comportamento indefinido. A conversão não custa nada e elimina a classe inteira do problema.

E prefira essas funções a testes feitos à mão. c >= '0' && c <= '9' por acaso funciona, mas isdigit(c) diz o que você quer dizer e continua correto em todo lugar.

limits.h e float.h - as bordas dos tipos

Quão grande pode ficar um int nesta máquina? Esses cabeçalhos respondem, e as respostas são a razão pela qual código portável pergunta em vez de supor.

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("char  : %d a %d (%zu byte)\n", CHAR_MIN, CHAR_MAX, sizeof(char));
    printf("int   : %d a %d (%zu bytes)\n", INT_MIN, INT_MAX, sizeof(int));
    printf("long  : %ld a %ld (%zu bytes)\n", LONG_MIN, LONG_MAX, sizeof(long));
    printf("uint  : 0 a %u\n", UINT_MAX);

    printf("float : %g a %g (%zu bytes)\n", FLT_MIN, FLT_MAX, sizeof(float));
    printf("double: %g a %g (%zu bytes)\n", DBL_MIN, DBL_MAX, sizeof(double));
    printf("double tem %d digitos decimais de precisao\n", DBL_DIG);
    return 0;
}

INT_MAX é como você verifica um estouro antes de ele acontecer, o que importa porque o estouro com sinal é comportamento indefinido, e não um giro que você possa testar depois.

stdbool.h e stdint.h - tipos melhores

O C não teve um tipo booleano até o C99. O <stdbool.h> fornece um:

#include <stdio.h>
#include <stdbool.h>

bool is_even(int n) {
    return n % 2 == 0;
}

int main(void) {
    bool ready = true;
    bool done  = false;

    printf("pronto=%d concluido=%d\n", ready, done);
    printf("is_even(10) = %s\n", is_even(10) ? "verdadeiro" : "falso");
    return 0;
}

bool, true e false são macros para _Bool, 1 e 0, mas deixam a intenção óbvia. (No C23 eles viraram palavras-chave e o cabeçalho deixou de ser necessário.)

O <stdint.h> dá tipos com larguras garantidas - essenciais para formatos de arquivo, protocolos de rede e qualquer coisa embarcada, onde "um int provavelmente tem 32 bits" não é bom o bastante:

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

int main(void) {
    int8_t   small = -128;
    uint16_t port  = 8080;
    int32_t  count = 2000000000;
    uint64_t big   = 18000000000000000000ULL;

    printf("int8_t  : %" PRId8  "\n", small);
    printf("uint16_t: %" PRIu16 "\n", port);
    printf("int32_t : %" PRId32 "\n", count);
    printf("uint64_t: %" PRIu64 "\n", big);

    printf("tamanhos: %zu %zu %zu %zu\n",
           sizeof small, sizeof port, sizeof count, sizeof big);
    return 0;
}

As macros no estilo PRId32, de <inttypes.h>, expandem para o especificador correto do printf para cada tipo de largura fixa na plataforma atual - que é a forma portável de imprimi-los, já que %d é certo para int32_t em alguns sistemas e errado em outros.

assert.h - conferindo suas suposições

assert(expr) não faz nada quando a expressão é verdadeira e aborta o programa com uma mensagem quando é falsa.

#include <stdio.h>
#include <assert.h>

int divide(int a, int b) {
    assert(b != 0);          /* um contrato: chamadores nao devem passar 0 */
    return a / b;
}

int main(void) {
    printf("20 / 4 = %d\n", divide(20, 4));
    printf("20 / 5 = %d\n", divide(20, 5));

    /* divide(20, 0) aqui abortaria com:
       Assertion `b != 0' failed. */
    return 0;
}

Compilar com -DNDEBUG remove todas as asserções, então elas não custam nada numa build de release. E esse é também o alerta: nunca coloque um efeito colateral dentro de um assert. assert(read_next() > 0) deixa de ler por completo na build de release, e o bug resultante aparece só em produção.

Asserções são para os seus erros - condições que deveriam ser impossíveis se o código estiver correto. Entrada ruim do usuário não é uma asserção; é um if e uma mensagem de erro.

O resto, em resumo

• <stddef.h> - size_t, ptrdiff_t, NULL, offsetof
• <stdarg.h> - funções variádicas, a maquinaria por trás do printf
• <errno.h> - errno mais perror e strerror para reportar por que uma chamada falhou
• <signal.h> - tratamento de sinais como o Ctrl-C
• <setjmp.h> - saltos não locais; raramente a resposta certa
• <locale.h>, <wchar.h>, <wctype.h> - locales e caracteres largos
• <stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h> - acréscimos do C11

Dois hábitos tornam a biblioteca agradável de usar. Leia a página de manual antes de chutar uma assinatura - man 3 strtol no macOS e no Linux é autoritativo e rápido. E confira valores de retorno: malloc, fopen e strtol todos reportam falha, e um programa que os ignora falha muito mais tarde e de forma muito menos clara.