Lenguajes y Fundamentos de Programación · LNG-150

C desde cero

Punteros, memoria y compilación: el lenguaje que explica cómo funciona todo lo que hay debajo.

Bajo demanda Iniciación 8 módulos · 40 clases

Formato asíncrono Alumnado, Docentes FP, Ingeniería / Industria C, JupyterLab

DESARROLLO HARDWARE FP JUPYTER

Lo que aprenderás

Declarar variables con los tipos de C y prever su tamaño en memoria con sizeof.
Manipular punteros y aritmética de direcciones para recorrer arrays y estructuras.
Reservar y liberar memoria dinámica con malloc, calloc, realloc y free sin fugas.
Compilar con gcc controlando las fases de preprocesado, compilación y enlazado.
Definir structs y uniones para representar registros y tramas de datos.
Leer y escribir ficheros de texto y binarios con las funciones de stdio.
Detectar accesos indebidos a memoria ejecutando el programa bajo Valgrind.

Contenido del curso

8 módulos · 40 clases en vídeo · práctica guiada en cada módulo

Módulo 1 · Presentación y entorno 4 clases

Dónde sigue vivo C y por qué conviene conocerlo
Primer programa en cuaderno con el kernel de C
Del código fuente al ejecutable: las cuatro fases
gcc, avisos y opción -Wall

Módulo 2 · Tipos, variables y operadores 5 clases

Enteros con y sin signo, tamaños y desbordamiento
Coma flotante y sus límites
Caracteres y la tabla ASCII
Operadores a nivel de bit
sizeof y representación en memoria

Módulo 3 · Control de flujo y funciones 5 clases

Condicionales y switch
Bucles for, while y do-while
Definir funciones y prototipos
Paso por valor y ámbito de las variables
Recursión con ejemplos medibles

Módulo 4 · Punteros 6 clases

Direcciones, referencia y desreferencia
Punteros y arrays: la misma cosa vista de dos formas
Aritmética de punteros
Paso por referencia a funciones
Punteros a función
Errores clásicos: puntero nulo y puntero colgante

Módulo 5 · Memoria dinámica 5 clases

Pila y montón: qué vive en cada sitio
malloc, calloc, realloc y free
Fugas de memoria y cómo se manifiestan
Ejecutar el programa bajo Valgrind
Ejercicio: lista enlazada sin fugas

Módulo 6 · Cadenas, structs y ficheros 5 clases

Cadenas terminadas en cero y funciones de string.h
Desbordamiento de buffer: qué ocurre exactamente
structs, uniones y enumerados
Ficheros de texto con fopen y fgets
Lectura y escritura binaria con fread y fwrite

Módulo 7 · Compilación y depuración 5 clases

Preprocesador, macros y cabeceras
Compilación separada y enlazado
Escribir un Makefile mínimo
Depurar con gdb: puntos de ruptura y pila
Bibliotecas estáticas y dinámicas

Módulo 8 · Caso práctico: analizador de ficheros binarios 5 clases

Formato del fichero y estructura de datos
Lectura por bloques y validación
Informe de resultados por salida estándar
Comprobación de memoria y avisos del compilador
Entrega: programa compilable con Makefile

Requisitos

No se necesita experiencia previa en programación.
Basta con un navegador para las primeras prácticas en JupyterLab.
Para el bloque de compilación conviene un equipo con Linux o WSL y gcc instalado.

Descripción

Casi todo lo que se programa hoy descansa sobre C: el núcleo de Linux, los intérpretes de Python y Ruby, los controladores de dispositivo y el firmware de cualquier placa. Quien nunca ha escrito C tiende a ver la memoria como algo abstracto, y eso pasa factura en cuanto hay que entender un desbordamiento, un puntero colgante o el consumo real de una estructura.

El curso empieza en cuaderno para que la sintaxis no se coma la atención, y pasa pronto a la línea de comandos, que es donde C se entiende de verdad: compilar por fases, leer los avisos del compilador, seguir la ejecución con gdb y comprobar la memoria con Valgrind. Se programan estructuras de datos sencillas y un programa que trata ficheros binarios.

Al terminar se lee código C sin sobresaltos y se entienden los mensajes de error que hasta ahora parecían crípticos. Abre paso a C++ moderno, a la programación de sistemas embebidos y microcontroladores, y a cualquier asignatura de sistemas operativos o de arquitectura donde se dé por sabido lo que ocurre en la pila y en el montón.

¿Para quién es este curso?

Alumnado de ciclos de informática o de ingeniería que se enfrenta a sistemas operativos o arquitectura.
Profesorado de FP que prepara prácticas de programación de bajo nivel y necesita ejemplos reproducibles.
Ingeniería industrial o de telecomunicación que trabajará con microcontroladores y firmware.