Curso de C Avanzado para empresas — Código robusto y seguro

Revisión profunda de punteros

Punteros a punteros (`char**`, `int**`)

Punteros a estructuras y casting

Punteros a funciones: sintaxis y uso

Arrays de punteros a funciones

Uso en callbacks y dispatch tables

Práctica: sistema de eventos con funciones dinámicas

Práctica adicional: registrador de operaciones dinámico

Riesgos de punteros mal inicializados

Validación y seguimiento en ejecución

Allocación dinámica con `malloc`, `calloc`, `realloc`

Cómo funciona el heap internamente

Fragmentación de memoria y técnicas de control

Implementación de pool de memoria personalizado

Práctica: memoria estática vs dinámica en simulador

Detección de errores: double free, overflows

Valgrind como herramienta de depuración de memoria

Estrategias de manejo de buffers

Liberación segura y patrones de propiedad

Avoiding memory leaks en entornos persistentes

Anidamiento de estructuras

Arrays de estructuras y estructuras con arrays

Uniones (`union`) y usos en protocolos

Bit fields en estructuras: optimización de espacio

Estructuras auto-referenciadas (listas, árboles)

Punteros dentro de estructuras y relocación

Práctica: implementar una tabla de símbolos

Serialización binaria de estructuras

Padding y alineación forzada

Uso seguro de `memcpy`, `memset`, `offsetof`

Cómo funciona la compilación de C paso a paso

Traducción a objetos intermedios (`.o`)

Linkado estático y dinámico

Tablas de símbolos y `nm`, `objdump`

`ar`, `ld`, `ranlib`, `readelf`

Práctica: crear una librería estática `.a` y dinámica `.so`

`extern`, `static` y visibilidad de símbolos

Resolución de dependencias cruzadas

Linking manual avanzado

Separación de responsabilidades por archivo

Uso avanzado del preprocesador `#define`, `#if`, `#pragma`

Macros con argumentos y técnicas seguras

`##`, `#` y manipulación de tokens

Técnicas para logging, debug y perfiles

Práctica: macro para trazado automático de funciones

Macros para benchmarking y medición de rendimiento

Abuso de macros y cómo evitarlos

Diferencias entre macro y funciones inline

Uso de `__FILE__`, `__LINE__` y otros built-ins

Header guards y `#pragma once`

Introducción a POSIX threads

Creación y sincronización de hilos

`pthread_create`, `pthread_join`, `pthread_exit`

Mutex, semáforos y condiciones

Práctica: sumador concurrente de matrices

Riesgos: race conditions, deadlocks

Atomicidad y memoria compartida

Uso correcto de `pthread_mutex_t`, `pthread_cond_t`

Patrones comunes de sincronización

Cierre limpio y gestión de recursos por hilo

`fork()`, `exec()` y creación de procesos

Comunicación entre procesos con `pipe()`

Uso de señales (`signal`, `sigaction`)

Práctica: sistema padre-hijo con pipes y control de señal

Manejadores seguros de señal

`kill`, `raise`, `alarm` y control de tiempo

Buffers con `dup2` y redirección de E/S

Programación defensiva con señales

Procesos zombis y `wait()`

Seguridad en ejecución de procesos externos

Introducción al testing en C

Frameworks como `cmocka`, `Check`, `Unity`

Práctica: tests para funciones de utilidades matemáticas

Mocking y sustitución de dependencias

Organización de pruebas por módulo

Validación estructural y lógica

Asserts avanzados y estrategias de cobertura

CI con `make test` y reporting

Medición de tiempo de ejecución

Reporte y cobertura con herramientas externas

Medir rendimiento con `gprof` y `perf`

Técnicas de inlining manual y expansión de loops

Eliminación de branching innecesario

Profiling de consumo de memoria

Análisis de instrucciones por ciclo (CPI)

Práctica: optimizar rutina intensiva con profiler

Microbenchmarking con `clock_gettime()`

`volatile`, `restrict` y su uso correcto

Compilación con `-O1`, `-O2`, `-O3`, `-Ofast`

Uso de `valgrind --tool=callgrind` para optimización

Lectura y escritura binaria avanzada

`fopen`, `fread`, `fwrite`, `fseek`, `ftell`, `ferror`

Streams estándar vs custom (archivos, sockets, etc.)

Modos de apertura y buffering

Práctica: leer y escribir estructuras binarias en disco

Mapeo de archivos a memoria (`mmap`)

Streams personalizados con `fopencookie` (GNU)

Control de errores y recuperación

Implementar logs rotativos

Cierre seguro y limpieza de recursos

Implementación de listas enlazadas (simples, dobles)

Pilas (stacks) y colas (queues) con punteros

Árboles binarios y árboles balanceados (AVL)

Tablas hash con funciones de dispersión propias

Práctica: sistema de agenda en RAM con búsqueda por nombre

Manejo de punteros circulares

Gestión de memoria dinámica por nodo

Funciones recursivas vs iterativas

Listas genéricas con `void*`

Consideraciones de eficiencia y complejidad

Validación estricta de entradas y buffers

Evitar desbordamientos con `strncpy`, `snprintf`

Inicialización correcta de estructuras

Uso seguro de `malloc` y control de NULL

Gestión correcta de errores y códigos de retorno

Práctica: funciones seguras con fallback

Limitar uso de funciones peligrosas (`gets`, `strcpy`, etc.)

Protección de punteros dobles y referencias colgantes

Fugas y corrupción de heap: cómo prevenirlas

Patrón “fail-safe” en C

Acceso a registros de memoria mapeada (`volatile`)

Controladores de bajo nivel

Manipulación de bits y máscaras

Práctica: emulación de GPIO con estructuras y máscaras

E/S en puertos con `inb`, `outb`

Sincronización con interrupciones

Uso de `__attribute__((packed))` y `aligned()`

Interacción con buses de hardware (I2C, SPI, etc.)

Proyectos en sistemas embebidos (Raspberry Pi, STM32)

Simulación de controladores

Alineación de datos entre arquitecturas

Endianness: detección y gestión (`htonl`, `ntohl`)

Portable types (`uint32_t`, `size_t`, `intptr_t`)

Preprocesador y condicionales por plataforma

Empaquetado portable de estructuras

Práctica: aplicación que detecta arquitectura y adapta formato

Consideraciones en compilación cruzada

Biblioteca estándar POSIX vs ANSI C

Reutilización entre Linux, Windows y Embedded

Errores comunes en migración multiplataforma

Separación por capa: driver, lógica, interfaz

Creación de librerías compartidas

`extern`, `static` y visibilidad en múltiples archivos

Uso de `Makefile` o `CMake` para proyectos modulares

Organización en carpetas por rol (src/, inc/, lib/, bin/)

Práctica: proyecto con librería matemática externa

Encapsulamiento de estructuras en headers

Reducción de dependencias cruzadas

Interface-ptr idiom

Diseño testable y mantenible

Breakpoints, watchpoints y stepping

Examinar pila, registros y variables (`info`, `backtrace`)

Visualización de estructuras complejas

Práctica: debugging de lista enlazada rota

Scripts de GDB y macros automatizadas

Visualización con `cgdb`, `gdb-dashboard`, VS Code

Uso combinado con Valgrind (`vgdb`)

Dump de memoria y análisis binario

Dump de core (`ulimit`, `core_pattern`)

Técnicas de depuración post-mortem

`cppcheck`, `clang-tidy`, `splint`

Integración con CI/CD

Práctica: pipeline básico con análisis estático automático

Detección de variables sin inicializar

Validación de tipos y accesos peligrosos

Visualización de dependencias

Reportes HTML y anotaciones de código

Detección de complejidad ciclomática

Precommit hooks con validadores

Interpretación de resultados y refactor basado en métricas

Acceso a syscalls con `syscall()`, `read`, `write`, `open`

Procesos: `fork`, `wait`, `exec`

Programación con `select`, `poll`, `epoll`

Manejo de señales personalizadas

Práctica: reloj de consola usando señales y pipes

Control de archivos y permisos (`chmod`, `stat`, `fchmod`)

Directorios (`opendir`, `readdir`)

Threads vs procesos: diferencias y casos de uso

Pipes con FIFO (`mkfifo`)

Hooks de shutdown y limpieza

Diseño de arquitectura modular

Servidor concurrente multicliente TCP

Parsing de paquetes binarios

Gestión de memoria eficiente

Práctica: implementación completa paso a paso

Logging, configuración y debug

Testing y validación con scripts

Profiling de rendimiento

Empaquetado en `.tar.gz` y documentación

Publicación en repositorio con Makefile y guía de instalación