El estándar C23 formalmente ISO/IEC 9899:2024, aprobado en diciembre de 2024 es la revisión más importante del lenguaje C desde C11. Aunque C evoluciona despacio por diseño, esta versión trae cambios que los desarrolladores llevan años pidiendo: sintaxis más moderna, semántica más clara y mejor interoperabilidad con hardware. GCC 15 y Clang 20, ambos disponibles en 2025, ya implementan la mayor parte del estándar.
¿Por qué C23 y no C++ o Rust?
C sigue siendo el lenguaje de referencia en sistemas embebidos, kernels, drivers y código de infraestructura crítica. No porque sea perfecto, sino porque es predecible, portable y tiene décadas de soporte en toolchains para arquitecturas que C++ o Rust aún no cubren. C23 mejora el lenguaje sin romper compatibilidad con código C99 o C11 existente.
Las novedades más importantes de C23
#embed incluir archivos binarios directamente
Una de las adiciones más prácticas. Antes, incrustar recursos binarios en un ejecutable requería convertirlos a arrays manualmente con xxd o herramientas similares. Ahora:
const unsigned char icono[] = {
#embed "icono.png"
};
El compilador incluye el contenido del archivo como una lista de valores enteros. Limpio, portable y sin scripts de generación de código.
typeof y typeof_unqual
typeof existía como extensión de GCC desde hace años, pero ahora es parte del estándar. Permite declarar variables del mismo tipo que otra expresión sin repetirlo:
int x = 42; typeof(x) y = 100; /* y es int */ typeof(x * 3.14) z; /* z es double (conversión implícita) */
typeof_unqual hace lo mismo pero elimina calificadores const o volatile del tipo resultante. Muy útil para macros genéricas.
nullptr constante de puntero nulo tipada
En C anterior, NULL se definía como (void*)0 o simplemente 0, lo que podía causar ambigüedades. C23 introduce nullptr con tipo nullptr_t, análogo al de C++11:
void* p = nullptr; char* s = nullptr; /* nullptr_t: tipo de nullptr */ typeof(nullptr) nulo;
No requiere ningún #include. El compilador ya lo conoce.
bool, true y false sin <stdbool.h>
Hasta C17, los keywords bool, true y false requerían incluir <stdbool.h>. En C23 son palabras clave del lenguaje directamente, igual que int o char. Código limpio sin cabeceras innecesarias.
static_assert sin <assert.h>
Similar al caso anterior. static_assert ahora es una keyword nativa:
static_assert(sizeof(int) == 4, "Se requiere int de 32 bits");
Comprobaciones en tiempo de compilación sin necesidad de incluir nada.
Atributos estándar: [[nodiscard]], [[deprecated]], [[maybe_unused]]
C23 adopta la sintaxis de atributos de C++11 con doble corchete:
[[nodiscard]] int abrir_fichero(const char* ruta);
[[deprecated("usa nueva_funcion() en su lugar")]]
void funcion_vieja(void);
[[maybe_unused]] static void funcion_debug(void) { /* ... */ }
[[nodiscard]] provoca un aviso del compilador si el valor de retorno se ignora. [[deprecated]] avisa al usar la función. [[maybe_unused]] silencia avisos de variables o funciones no utilizadas.
Literales binarios y _BitInt(N)
Los literales binarios con prefijo 0b son ahora estándar:
unsigned char flags = 0b10110100;
_BitInt(N) define enteros de ancho de bit arbitrario, muy útil en protocolos y hardware:
_BitInt(48) timestamp; /* entero de 48 bits exactos */ _BitInt(3) modo; /* valores de 0 a 7 */
Especialmente relevante en sistemas embebidos donde los registros tienen anchos no estándar.
GCC 15 y Clang 20: estado del soporte
GCC 15 (mayo 2025) usa gnu23 como estándar por defecto si no se especifica ningún flag. Para C23 puro sin extensiones GNU, usar -std=c23. Clang 20 (2025) ofrece soporte completo de C23 con -std=c23. Ambos compiladores implementan todas las características descritas arriba.
/* Compilar con GCC 15 */ gcc -std=c23 -Wall -Wextra -o programa programa.c /* Compilar con Clang 20 */ clang -std=c23 -Wall -Wextra -o programa programa.c
Para verificar qué versión del estándar usa tu compilador por defecto: gcc -dM -E - < /dev/null | grep __STDC_VERSION__. C23 corresponde al valor 202311L.
Compatibilidad hacia atrás
C23 mantiene compatibilidad con C99 y C11 en la práctica. Las palabras clave nuevas (bool, true, nullptr) solo son un problema si tu código las usaba como identificadores, algo poco común. La migración gradual es perfectamente posible: se puede usar -std=c23 en proyectos existentes y corregir los pocos conflictos que aparezcan.
Si te interesa la evolución del lenguaje hacia C++, puedes ver qué trae C++26 en reflexión y seguridad de memoria o explorar Zig 0.14 como alternativa moderna a C.
Imagen: Pexels / Al Nahian