Setup: el toolchain moderno de C · C23 moderno

En sistemas, tu compilador es tu herramienta más importante. Antes de escribir una línea seria, hay que montar el entorno bien y aprender a hablar con el compilador — porque un compilador bien configurado es tu primer y mejor detector de errores.

🎯 Al terminar esta lección sabrás

Instalar GCC y Clang.
Compilar tu primer programa C23.
Los flags de aviso imprescindibles.
Por qué usar dos compiladores.

Instalar los compiladores

Los dos grandes compiladores de C son GCC (GNU) y Clang (LLVM). Instala ambos: cada uno detecta cosas que el otro no.

# Linux (Debian/Ubuntu)
sudo apt install gcc clang gdb valgrind

# macOS: clang viene con las Command Line Tools
xcode-select --install
brew install gcc llvm      # gcc real, además del clang del sistema

# comprueba las versiones (necesitas soporte de C23)
gcc --version    # GCC 14+ para -std=c23 completo
clang --version  # Clang 18+ para -std=c23 completo

ℹ️

C23: -std=c23 o -std=c2x

Los compiladores recientes aceptan -std=c23. En versiones algo anteriores el nombre era provisional, -std=c2x. Si -std=c23 te da error, prueba -std=c2x. En 2026, con GCC 14+/Clang 18+, usa -std=c23.

Tu primer programa

Crea hola.c:

#include <stdio.h>

int main(void) {
    printf("Hola, sistemas.\n");
    return 0;
}

Compílalo y ejecútalo:

gcc -std=c23 hola.c -o hola
./hola
# Hola, sistemas.

-o hola nombra el ejecutable; sin él, GCC produce a.out (herencia histórica).

Los flags que salvan vidas

Compilar “a pelo” oculta problemas. Un desarrollador de C serio siempre activa avisos. Este es el conjunto base:

gcc -std=c23 -Wall -Wextra -Wpedantic -Werror -g -O2 hola.c -o hola

Flag	Qué hace
`-Wall`	activa los avisos comunes (no “all”, irónicamente)
`-Wextra`	avisos adicionales que `-Wall` no cubre
`-Wpedantic`	exige C estándar estricto, sin extensiones
`-Werror`	convierte los avisos en errores (te obliga a arreglarlos)
`-g`	incluye símbolos de depuración (para gdb)
`-O2`	optimización (activa análisis que revelan más avisos)

⚡

El compilador es tu primer sanitizer

El error de novato es tratar los avisos como ruido y silenciarlos. El profesional hace lo contrario: activa -Wall -Wextra -Werror y trata cada aviso como un bug a resolver. La inmensa mayoría de los bugs de C —variables sin inicializar, conversiones peligrosas, comparaciones con signo, código muerto— el compilador ya los ve si se lo permites. Gratis, en cada compilación, antes de ejecutar nada. Configurar bien el compilador desde el minuto cero te ahorra más depuración que cualquier otra técnica. Es la herramienta de calidad más barata que existe.

Por qué dos compiladores

GCC y Clang implementan el mismo estándar, pero su análisis difiere. Un aviso que GCC no da, Clang sí, y viceversa. Compilar tu código con ambos (y con -Werror) es una red de seguridad doble por casi ningún esfuerzo. Además, Clang trae herramientas fantásticas (los sanitizers del nivel 24, clang-tidy del 25) que aprovecharás más adelante.

# el mismo código, dos jueces
gcc   -std=c23 -Wall -Wextra -Werror prog.c -o prog_gcc
clang -std=c23 -Wall -Wextra -Werror prog.c -o prog_clang

💡

Automatiza estos flags

Escribir esa ristra de flags cada vez es tedioso y propenso a olvidos. En el nivel 17 (Meson) y el 18 (Make) los pondrás una sola vez en tu configuración de build. Por ahora, un alias o un pequeño script te sirve para no compilar nunca sin avisos.

⚔️ Monta tu entorno

Instala GCC, Clang, gdb y Valgrind. Comprueba que soportan -std=c23.
Compila el “Hola, sistemas” con el set completo de flags.
Introduce un bug a propósito (una variable sin usar, o comparar con signo) y observa cómo -Werror te detiene.
Compila el mismo archivo con GCC y con Clang y compara sus mensajes.