La biblioteca estándar de C: un mapa de las cabeceras que vale la pena conocer

El lenguaje C es minúsculo: tipos, operadores, control de flujo, funciones, punteros. No puede imprimir, leer un archivo, comparar una cadena ni reservar memoria. Todo eso es la biblioteca estándar: un conjunto de cabeceras que toda implementación conforme incluye.

Esta página es un mapa. Cada sección dice para qué sirve una cabecera, muestra un ejemplo corto y funcional, y apunta a la página más completa donde exista.

stdio.h: entrada y salida

La cabecera que incluyes primero en casi todo programa. Contiene printf y scanf, el tipo FILE y las funciones de archivos, y las funciones de entrada por líneas más seguras.

#include <stdio.h>

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

    /* fputs escribe sin interpretar especificadores de formato */
    fputs("Salida simple, sin formato\n", stdout);

    /* stderr es un flujo aparte para diagnosticos */
    fprintf(stderr, "Esto va al error estandar\n");

    /* putchar escribe un solo caracter */
    for (char c = 'a'; c <= 'e'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

Lo esencial: printf, fprintf, sprintf, snprintf para salida; scanf, fscanf, sscanf, fgets, getchar para entrada; fopen, fclose, fread, fwrite, fseek para archivos. La cobertura más profunda vive en printf, scanf y manejo de archivos.

Una regla que conviene llevarse: nunca uses gets(). No tiene forma de conocer el tamaño de tu búfer y fue eliminada del estándar en C11. fgets(buf, sizeof buf, stdin) es el reemplazo.

stdlib.h: utilidades generales

El cajón de sastre: memoria, conversiones, aleatoriedad, control de procesos, ordenamiento.

#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) {
    /* de cadena a 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 cualquier cosa si le das una funcion de comparacion */
    qsort(nums, 5, sizeof *nums, compare_ints);
    for (int i = 0; i < 5; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    free(nums);
    return 0;
}

Lo destacado: malloc, calloc, realloc, free (mira memoria dinámica); atoi, atof, strtol, strtod para conversiones —prefiere la familia strto*, que puede reportar fallos donde atoi devuelve 0 en silencio—; rand y srand (mira números aleatorios); exit, abort, getenv, system; y qsort/bsearch.

string.h: cadenas y bloques de memoria

Las cadenas de C son arrays de char que terminan en '\0', y cada operación sobre ellas es una llamada a función.

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

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

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

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

    printf("strcmp  : %d\n", strcmp("manzana", "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);

    /* las funciones mem* trabajan sobre bytes crudos, no solo texto */
    char block[10];
    memset(block, '-', 9);
    block[9] = '\0';
    printf("memset  : %s\n", block);
    return 0;
}

Dos hábitos evitan que esta cabecera se convierta en una fuente de desbordamientos de búfer: conoce siempre el tamaño del destino, y recuerda que strcmp devuelve 0 cuando son iguales, así que if (strcmp(a, b)) es verdadero cuando las cadenas difieren. Funciones de cadenas cubre en detalle los patrones más seguros con strncpy/snprintf.

math.h: matemáticas

sqrt, pow, fabs, floor, ceil, round, fmod, las familias trigonométrica y logarítmica, INFINITY y 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;
}

Esta es la única cabecera que puede necesitar una bandera del enlazador: en Linux, agrega -lm al final del comando de compilación o el enlazador reporta "undefined reference to sqrt". Recorrido completo en funciones matemáticas.

time.h: relojes y fechas

#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("Con formato: %s\n", buf);

    /* clock() mide el tiempo de procesador 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("El bucle tomo %.4f segundos de CPU\n", secs);
    return 0;
}

Los dos desplazamientos de struct tm atrapan a todo el mundo: tm_year cuenta desde 1900 y tm_mon empieza en 0. time(NULL) es también la semilla habitual de srand.

ctype.h: clasificación de caracteres

Pequeña y más útil de lo que parece. Cada función toma un carácter y responde una pregunta de sí o no, o convierte mayúsculas y minúsculas.

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

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

    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 espacios=%d puntuacion=%d\n",
           letters, digits, spaces, punct);

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

El conjunto completo: isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, más toupper y tolower.

Fíjate en la conversión (unsigned char). Estas funciones están definidas para valores representables como unsigned char más EOF; un char a secas tiene signo en la mayoría de los sistemas, así que un byte por encima de 127 llega como un número negativo y la llamada pasa a ser comportamiento indefinido. La conversión no cuesta nada y elimina toda esa clase de problema.

Y prefiere estas a las pruebas escritas a mano. c >= '0' && c <= '9' da la casualidad de funcionar, pero isdigit(c) dice lo que quieres decir y sigue siendo correcto en todas partes.

limits.h y float.h: los bordes de los tipos

¿Cuán grande puede ser un int en esta máquina? Estas cabeceras lo responden, y las respuestas son por lo que el código portable pregunta en lugar de suponer.

#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 tiene %d digitos decimales de precision\n", DBL_DIG);
    return 0;
}

INT_MAX es como compruebas el desbordamiento antes de que ocurra, lo que importa porque el desbordamiento con signo es comportamiento indefinido y no una vuelta a la carga que puedas comprobar después.

stdbool.h y stdint.h: mejores tipos

C no tuvo tipo booleano hasta C99. <stdbool.h> aporta uno:

#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("ready=%d done=%d\n", ready, done);
    printf("is_even(10) = %s\n", is_even(10) ? "true" : "false");
    return 0;
}

bool, true y false son macros para _Bool, 1 y 0, pero hacen obvia la intención. (En C23 pasaron a ser palabras clave y la cabecera ya no es necesaria.)

<stdint.h> da tipos con anchos garantizados, imprescindibles para formatos de archivo, protocolos de red y cualquier cosa embebida, donde "un int probablemente tiene 32 bits" no basta:

#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("tamanos: %zu %zu %zu %zu\n",
           sizeof small, sizeof port, sizeof count, sizeof big);
    return 0;
}

Las macros al estilo PRId32 de <inttypes.h> se expanden al especificador de printf correcto para cada tipo de ancho fijo en la plataforma actual, que es la forma portable de imprimirlos, ya que %d es correcto para int32_t en unos sistemas y equivocado en otros.

assert.h: comprobar tus suposiciones

assert(expr) no hace nada cuando la expresión es verdadera y aborta el programa con un mensaje cuando es falsa.

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

int divide(int a, int b) {
    assert(b != 0);          /* un contrato: quien llame no debe pasar 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 con:
       Assertion `b != 0' failed. */
    return 0;
}

Compilar con -DNDEBUG elimina todas las aserciones, así que no cuestan nada en una versión de lanzamiento. Esa es también la advertencia: nunca pongas un efecto secundario dentro de un assert. assert(read_next() > 0) deja de leer por completo en la versión de lanzamiento, y el error resultante aparece solo en producción.

Las aserciones son para tus errores: condiciones que deberían ser imposibles si el código es correcto. Una entrada de usuario mala no es una aserción; es un if y un mensaje de error.

El resto, en breve

• <stddef.h>: size_t, ptrdiff_t, NULL, offsetof
• <stdarg.h>: funciones variádicas, la maquinaria detrás de printf
• <errno.h>: errno más perror y strerror para reportar por qué falló una llamada
• <signal.h>: manejo de señales como Ctrl-C
• <setjmp.h>: saltos no locales; rara vez la respuesta correcta
• <locale.h>, <wchar.h>, <wctype.h>: configuraciones regionales y caracteres anchos
• <stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h>: añadidos de C11

Dos hábitos hacen agradable el uso de la biblioteca. Lee la página del manual antes de adivinar una firma: man 3 strtol en macOS y Linux es autoritativo y rápido. Y comprueba los valores de retorno: malloc, fopen y strtol reportan fallos, y un programa que los ignora falla mucho después y de forma mucho menos clara.