Ejercicios: Compilación y Makefiles

Prerrequisitos y Entorno de Ejecución Requerido¶

Para compilar y verificar las soluciones de este módulo bajo el estándar C11 estricto de cátedra, se requiere:

Compilador C11: GCC 9+ o Clang 11+ configurado con flags -Wall -Wextra -Werror -pedantic -std=c11.
Entorno POSIX: Linux o WSL con utilidades estándar (make, ar, diff, bash).
Herramientas de Automatización: GNU Make 4.0+ y soporte para compilación modular multiobjeto.
Conocimientos Previos: Etapas de compilación (preprocesado, compilación, ensamblado, enlazado), archivos objeto (.o), bibliotecas estáticas (.a) y reglas con targets/dependencias.

Objetivos Pedagógicos y Competencias (Taxonomía de Bloom)¶

Nivel 2 (Comprensión): Analizar el flujo de traducción de código fuente a binario ejecutable y la separación en cabeceras e implementaciones.
Nivel 3 (Aplicación): Construir Makefiles modulares con variables automáticas ($@, $<, $^), reglas implícitas y targets phony (all, clean, test).
Nivel 4 (Análisis): Diagnosticar errores de enlazado (undefined reference vs multiple definition) y optimizar tiempos de compilación incremental.
Andamiaje Progresivo: Ejercicios andamiados con contratos formales (precondiciones/postcondiciones), tablas de vectores de prueba y suites ejecutables con assert().

Capítulos de Apunte Correspondientes¶

Proyecto Multi-archivo Manual¶

Ejercicio 1.08.01 - Separar un programa en módulos ⭐⭐☆☆☆¶

Exercise 1

Implementá las operaciones aritméticas básicas de un módulo de calculadora con tipado estricto y aserciones de prueba:

int calc_sumar(int a, int b)
int calc_restar(int a, int b)
int calc_multiplicar(int a, int b)
bool calc_dividir(int dividendo, int divisor, int *cociente): retorna false ante división por cero.

Tabla de Vectores de Prueba:

Caso de Prueba	Operación	Entradas	Retorno Esperado
Suma positiva	`calc_sumar`	`10, 5`	`15`
Resta con negativo	`calc_restar`	`5, 12`	`-7`
Multiplicación	`calc_multiplicar`	`4, -3`	`-12`
División válida	`calc_dividir`	`20, 4`	`true (*cociente == 5)`
División por cero	`calc_dividir`	`10, 0`	`false`

```c #include <stdio.h> #include <stdbool.h> #include <assert.h> int calc_sumar(int a, int b) { return a + b; } int calc_restar(int a, int b) { return a - b; } int calc_multiplicar(int a, int b) { return a * b; } bool calc_dividir(int dividendo, int divisor, int *cociente) { if (divisor == 0 || cociente == NULL) { return false; } *cociente = dividendo / divisor; return true; } int main(void) { assert(calc_sumar(10, 5) == 15); assert(calc_restar(5, 12) == -7); assert(calc_multiplicar(4, -3) == -12); int cociente = 0; assert(calc_dividir(20, 4, &cociente) == true); assert(cociente == 5); assert(calc_dividir(10, 0, &cociente) == false); assert(calc_dividir(10, 2, NULL) == false); return 0; } ```


(ej_b1_c08_02)=
### Ejercicio 1.08.02 - Compilación manual ⭐⭐☆☆☆

**Tarea**: Usando la terminal, compilá y enlazá los archivos del ejercicio
anterior sin usar un Makefile.

:::{hint} Lógica y Consideraciones
1.  **Compilar los archivos objeto (`.o`)**: Se usa la opción `-c` de `gcc` para
    compilar cada archivo fuente por separado.
    ```bash
    gcc -c main.c -o main.o
    gcc -c calculadora.c -o calculadora.o
    ```
2.  **Enlazar los objetos**: Se combinan los archivos objeto para crear el
    ejecutable final.
    ```bash
    gcc main.o calculadora.o -o mi_calculadora
    ```
    errores de E/S con `ferror` y `feof`.
    archivo en todos los caminos de ejecución.

Automatización con Makefile¶

Ejercicio 1.08.03 - Makefile básico ⭐☆☆☆☆¶

Tarea: Crear un Makefile para el proyecto del ejercicio anterior. El Makefile debe tener los siguientes objetivos (targets):

all: El objetivo por defecto, que debe compilar y enlazar todo el programa para crear el ejecutable mi_calculadora.
clean: Un objetivo “phony” que elimina todos los archivos generados por la compilación (.o y el ejecutable).

Estructura del Makefile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# Variable para el compilador
CC = gcc
# Flags de compilación
CFLAGS = -Wall -Wextra -g

# Archivos objeto necesarios
OBJS = main.o calculadora.o

# Nombre del ejecutable final
TARGET = mi_calculadora

all: $(TARGET)

$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) -o $(TARGET) $(OBJS)

main.o: main.c calculadora.h
	$(CC) $(CFLAGS) -c main.c

calculadora.o: calculadora.c calculadora.h
	$(CC) $(CFLAGS) -c calculadora.c

.PHONY: clean
clean:
	rm -f $(TARGET) $(OBJS)

Compilación Condicional¶

Ejercicio 1.08.04 - Mensajes de depuración ⭐⭐☆☆☆¶

Exercise 2

Implementá un sistema básico de registro de eventos con compilación condicional y niveles de severidad:

Definí niveles LOG_LEVEL_NONE (0), LOG_LEVEL_INFO (1), y LOG_LEVEL_DEBUG (2).
Si LOG_LEVEL no está definido en el preprocesador, debe establecerse por defecto en LOG_LEVEL_INFO.
Implementá una función size_t formatear_log(char *buffer, size_t capacidad, int nivel_mensaje, const char *mensaje) que guarde en buffer el prefijo "[DEBUG] " o "[INFO] " seguido del mensaje solo si nivel_mensaje <= LOG_LEVEL. Si el mensaje no califica por nivel o capacidad, debe retornar 0 y no modificar el buffer.

Tabla de Vectores de Prueba:

Caso de Prueba	Nivel de Mensaje	Nivel Activo (`LOG_LEVEL`)	Retorno Esperado	Contenido en Buffer
Info en nivel Info	`LOG_LEVEL_INFO`	1 (`INFO`)	`> 0`	`"[INFO] Sistema listo"`
Debug en nivel Info	`LOG_LEVEL_DEBUG`	1 (`INFO`)	`0`	`""` (filtrado)
Buffer insuficiente	`LOG_LEVEL_INFO`	1 (`INFO`)	`0`	Sin desborde

```c #include <stdio.h> #include <stdbool.h> #include <string.h> #include <assert.h> #define LOG_LEVEL_NONE 0 #define LOG_LEVEL_INFO 1 #define LOG_LEVEL_DEBUG 2 #ifndef LOG_LEVEL #define LOG_LEVEL LOG_LEVEL_INFO #endif size_t formatear_log(char *buffer, size_t capacidad, int nivel_mensaje, const char *mensaje) { if (buffer == NULL || capacidad == 0 || mensaje == NULL) { return 0; } if (nivel_mensaje > LOG_LEVEL || nivel_mensaje == LOG_LEVEL_NONE) { buffer[0] = '\0'; return 0; } const char *prefijo = (nivel_mensaje == LOG_LEVEL_DEBUG) ? "[DEBUG] " : "[INFO] "; size_t len_prefijo = strlen(prefijo); size_t len_mensaje = strlen(mensaje); if (len_prefijo + len_mensaje + 1 > capacidad) { buffer[0] = '\0'; return 0; } int escritos = snprintf(buffer, capacidad, "%s%s", prefijo, mensaje); if (escritos < 0 || (size_t)escritos >= capacidad) { buffer[0] = '\0'; return 0; } return (size_t)escritos; } int main(void) { char buf[64]; // Con LOG_LEVEL_INFO (1), INFO debe registrarse size_t n1 = formatear_log(buf, sizeof(buf), LOG_LEVEL_INFO, "Operacion iniciada"); assert(n1 > 0); assert(strcmp(buf, "[INFO] Operacion iniciada") == 0); // Con LOG_LEVEL_INFO (1), DEBUG debe ser descartado size_t n2 = formatear_log(buf, sizeof(buf), LOG_LEVEL_DEBUG, "Detalle interno"); assert(n2 == 0); assert(buf[0] == '\0'); // Buffer demasiado pequeño char pequeno[8]; size_t n3 = formatear_log(pequeno, sizeof(pequeno), LOG_LEVEL_INFO, "Texto muy largo"); assert(n3 == 0); // Parámetros nulos assert(formatear_log(NULL, 10, LOG_LEVEL_INFO, "Test") == 0); assert(formatear_log(buf, sizeof(buf), LOG_LEVEL_INFO, NULL) == 0); return 0; } ```


(ej_b1_c08_05)=
## Ejercicio 1.08.05 - Compilación Básica ⭐☆☆☆☆

Compilá un programa simple desde línea de comandos.

**Orientación:**

:::{hint} Lógica y Consideraciones
definición interna oculta en el archivo `.c`.
    para copiar la estructura de forma segura.

gcc -o programa programa.c
./programa

-o especifica nombre del ejecutable
Sin -o, crea a.out por defecto

Ejercicio 1.08.06 - Warnings Habilitados ⭐☆☆☆☆¶

Compilá con warnings completos y corregí los problemas.

Orientación:

gcc -Wall -Wextra -std=c99 -pedantic programa.c -o programa

-Wall: warnings comunes
-Wextra: warnings adicionales
-std=c99: estándar C99
-pedantic: estricto con estándar

Ejercicio 1.08.07 - Verificación de Arquitectura en Tiempo de Compilación con `_Static_assert` ⭐⭐☆☆☆¶

Exercise 3

En el desarrollo de software portable y de bajo nivel, los errores de suposición sobre el tamaño de tipos o el modelo de datos de la plataforma deben detectarse durante la fase de compilación, no en tiempo de ejecución. El estándar C11 introdujo la directiva _Static_assert(condicion_constante, "mensaje") para validar invariantes estáticos sin costo en el binario final.

Implementá un módulo de verificación de plataforma:

Declarar aserciones estáticas que garanticen que sizeof(int) >= 4, sizeof(void *) >= 4 y sizeof(char) == 1.
Implementar una función const char *obtener_modelo_datos_arquitectura(void) que determine en tiempo de ejecución si la arquitectura opera en modelo ILP32 (punteros de 4 bytes) o LP64 / LLP64 (punteros de 8 bytes).

Tabla de Vectores de Prueba Obligatorios¶

Verificación	Tipo Evaluado	Requisito Mínimo C11	Comportamiento
Tamaño Char	`char`	Exactamente 1 byte	Compilación exitosa (`_Static_assert`)
Tamaño Int	`int`	Al menos 4 bytes	Compilación exitosa (`_Static_assert`)
Puntero	`void *`	4 u 8 bytes	Retorno `"ILP32 (32-bit)"` o `"LP64/LLP64 (64-bit)"`

```c #include <stdio.h> #include <stddef.h> #include <string.h> #include <assert.h> // Validaciones estrictas en tiempo de compilación (C11) _Static_assert(sizeof(char) == 1, "char debe medir exactamente 1 byte"); _Static_assert(sizeof(int) >= 4, "int debe medir al menos 4 bytes"); _Static_assert(sizeof(void *) == 4 || sizeof(void *) == 8, "Puntero debe medir 4 u 8 bytes"); const char *obtener_modelo_datos_arquitectura(void) { if (sizeof(void *) == 8) { return "LP64/LLP64 (64-bit)"; } else if (sizeof(void *) == 4) { return "ILP32 (32-bit)"; } return "Arquitectura desconocida"; } int main(void) { const char *modelo = obtener_modelo_datos_arquitectura(); assert(modelo != NULL); if (sizeof(void *) == 8) { assert(strcmp(modelo, "LP64/LLP64 (64-bit)") == 0); } else { assert(strcmp(modelo, "ILP32 (32-bit)") == 0); } assert(sizeof(char) == 1); assert(sizeof(int) >= 4); return 0; } ```


---

(ej_b1_c08_08)=
## Ejercicio 1.08.08 - Include Guards ⭐⭐☆☆☆

Explicá por qué se necesitan include guards y implementalos.

**Orientación:**

:::{hint} Lógica y Consideraciones
valores fuera de rango o tipos inválidos.
    un lazo hasta que el usuario elija finalizar.

#ifndef MI_HEADER_H
#define MI_HEADER_H
// Contenido del header
#endif // MI_HEADER_H

Previene inclusión múltiple
Evita errores de redefinición

Ejercicio 1.08.09 - Makefile Básico ⭐⭐⭐☆☆¶

Creá Makefile para compilar proyecto de ejercicio 3.

Makefile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
CC = gcc
CFLAGS = -Wall -Wextra -std=c99

programa: main.o funciones.o
	$(CC) main.o funciones.o -o programa

main.o: main.c funciones.h
	$(CC) $(CFLAGS) -c main.c

funciones.o: funciones.c funciones.h
	$(CC) $(CFLAGS) -c funciones.c

clean:
	rm -f *.o programa

Uso:

make           # Compila
make clean     # Limpia

Ejercicio 1.08.10 - Biblioteca Matemática ⭐⭐⭐☆☆¶

Creá biblioteca con funciones matemáticas: factorial, potencia, fibonacci.

Estructura:

proyecto/
├── matematica.h
├── matematica.c
├── test.c
└── Makefile

Orientación:

matematica.h: declaraciones
matematica.c: implementaciones
test.c: programa que usa la biblioteca

Ejercicio 1.08.11 - Flags de Optimización ⭐⭐⭐☆☆¶

Compilá con diferentes niveles de optimización y medí diferencia.

Orientación:

gcc -O0 programa.c -o prog_O0  # Sin optimización
gcc -O1 programa.c -o prog_O1  # Básica
gcc -O2 programa.c -o prog_O2  # Recomendada
gcc -O3 programa.c -o prog_O3  # Agresiva

Medí tiempo de ejecución: time ./prog_O2
-O0 útil para debugging
-O2 balance entre velocidad y tamaño
-O3 máxima optimización

Ejercicio 1.08.12 - Compilación Condicional ⭐⭐⭐☆☆¶

Usá directivas de preprocesador para debug opcional.

Orientación:

#ifdef DEBUG
printf("Debug: valor = %d\n", valor);
#endif

Compilación:

gcc -DDEBUG programa.c -o programa  # Con debug
gcc programa.c -o programa           # Sin debug

Ejercicio 1.08.13 - Módulo de Utilidades ⭐⭐⭐⭐☆¶

Creá módulo utils con funciones de uso general: intercambio, mínimo, máximo.

Estructura:

1
2
3
4
5
6
7
8
9
10
11
12
13
// utils.h
#ifndef UTILS_H
#define UTILS_H
void intercambiar(int *a, int *b);
int minimo(int a, int b);
int maximo(int a, int b);
#endif
// utils.c
#include "utils.h"
// Implementaciones...
// main.c
#include "utils.h"
// Uso...

Ejercicio 1.08.14 - Makefile con Variables ⭐⭐⭐⭐☆¶

Mejorá Makefile usando variables y patrones.

Makefile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
CC = gcc
CFLAGS = -Wall -Wextra -std=c99 -O2
LDFLAGS = -lm

SRCS = main.c utils.c matematica.c
OBJS = $(SRCS:.c=.o)
TARGET = programa

$(TARGET): $(OBJS)
	$(CC) $(OBJS) $(LDFLAGS) -o $(TARGET)

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f $(OBJS) $(TARGET)

.PHONY: clean

Ejercicio 1.08.15 - Dependencias Automáticas ⭐⭐⭐⭐☆¶

Generá dependencias automáticamente con gcc.

Orientación:

DEPS = $(OBJS:.o=.d)

-include $(DEPS)

%.o: %.c
	$(CC) $(CFLAGS) -MMD -MP -c $< -o $@

-MMD: genera archivo .d con dependencias
-MP: crea targets phony para headers

Ejercicio 1.08.16 - Biblioteca Estática ⭐⭐⭐⭐⭐¶

Creá biblioteca estática (.a) y usala en programa.

Orientación:

1
2
3
4
5
6
7
8
# Compilar objetos
gcc -c modulo1.c modulo2.c

# Crear biblioteca estática
ar rcs libmibiblioteca.a modulo1.o modulo2.o

# Usar biblioteca
gcc main.c -L. -lmibiblioteca -o programa

ar: archiver, crea bibliotecas
-L.: buscar bibliotecas en directorio actual
-lmibiblioteca: enlazar con libmibiblioteca.a

Ejercicio 1.08.17 - Biblioteca Compartida ⭐⭐⭐⭐⭐¶

Creá biblioteca compartida (.so) y usala.

Orientación:

1
2
3
4
5
6
7
8
9
10
11
12
# Compilar con PIC (Position Independent Code)
gcc -fPIC -c modulo.c

# Crear biblioteca compartida
gcc -shared modulo.o -o libmodulo.so

# Compilar programa
gcc main.c -L. -lmodulo -o programa

# Ejecutar (necesita encontrar .so)
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
./programa

Ejercicio 1.08.18 - Proyecto Multi-Directorio ⭐⭐⭐⭐⭐¶

Organizá proyecto en directorios: src/, include/, obj/, bin/.

Estructura:

proyecto/
├── src/
│   ├── main.c
│   └── modulo.c
├── include/
│   └── modulo.h
├── obj/        (generado)
├── bin/        (generado)
└── Makefile

Makefile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
SRCDIR = src
INCDIR = include
OBJDIR = obj
BINDIR = bin

CFLAGS = -I$(INCDIR) -Wall -Wextra

SRCS = $(wildcard $(SRCDIR)/*.c)
OBJS = $(patsubst $(SRCDIR)/%.c,$(OBJDIR)/%.o,$(SRCS))

$(BINDIR)/programa: $(OBJS) | $(BINDIR)
	$(CC) $^ -o $@

$(OBJDIR)/%.o: $(SRCDIR)/%.c | $(OBJDIR)
	$(CC) $(CFLAGS) -c $< -o $@

$(OBJDIR) $(BINDIR):
	mkdir -p $@

Ejercicio 1.08.19 - Targets Adicionales ⭐⭐⭐⭐☆¶

Agregá targets útiles: run, test, install, uninstall.

Makefile:

1
2
3
4
5
6
7
8
9
10
11
12
13
run: $(TARGET)
	./$(TARGET)

test: $(TARGET)
	./$(TARGET) test_input.txt

install: $(TARGET)
	install -m 755 $(TARGET) /usr/local/bin/

uninstall:
	rm -f /usr/local/bin/$(TARGET)

.PHONY: run test install uninstall

Ejercicio 1.08.20 - Compilación Debug/Release ⭐⭐⭐⭐⭐¶

Makefile con modo debug y release.

Makefile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
MODE ?= release

ifeq ($(MODE),debug)
    CFLAGS += -g -O0 -DDEBUG
    TARGET = programa_debug
else
    CFLAGS += -O2 -DNDEBUG
    TARGET = programa
endif

all: $(TARGET)
	@echo "Compiled in $(MODE) mode"

# Uso:
# make              # Release
# make MODE=debug   # Debug

Ejercicio 1.08.21 - Análisis Estático ⭐⭐⭐⭐☆¶

Integrá herramientas de análisis en Makefile.

Makefile:

1
2
3
4
5
6
7
8
9
10
check: $(SRCS)
	cppcheck --enable=all $(SRCS)

format: $(SRCS)
	clang-format -i $(SRCS)

valgrind: $(TARGET)
	valgrind --leak-check=full ./$(TARGET)

.PHONY: check format valgrind

Ejercicio 1.08.22 - Cross-Compilation ⭐⭐⭐⭐⭐¶

Configurá cross-compilation para diferentes arquitecturas.

Makefile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Compilación nativa
CC_NATIVE = gcc
TARGET_NATIVE = programa

# Cross-compilation para ARM
CC_ARM = arm-linux-gnueabi-gcc
TARGET_ARM = programa_arm

arm: CC = $(CC_ARM)
arm: TARGET = $(TARGET_ARM)
arm: $(TARGET)

native: CC = $(CC_NATIVE)
native: TARGET = $(TARGET_NATIVE)
native: $(TARGET)

Ejercicio 1.08.23 - Sistema de Build Completo ⭐⭐⭐⭐⭐¶

Proyecto completo con múltiples bibliotecas y tests.

Estructura:

proyecto/
├── lib/
│   ├── util/
│   │   ├── util.h
│   │   └── util.c
│   └── math/
│       ├── math.h
│       └── math.c
├── src/
│   └── main.c
├── tests/
│   ├── test_util.c
│   └── test_math.c
└── Makefile

Orientación:

Compilar bibliotecas separadamente
Enlazar con main
Target para tests
Target para todo (all)

Ejercicio 1.08.24 - CMake Básico ⭐⭐⭐⭐⭐¶

Convertí proyecto a usar CMake en lugar de Makefile.

CMakeLists.txt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
cmake_minimum_required(VERSION 3.10)
project(MiProyecto C)

set(CMAKE_C_STANDARD 99)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra")

include_directories(include)

add_executable(programa
    src/main.c
    src/modulo.c
)

target_link_libraries(programa m)

# Tests
enable_testing()
add_executable(tests tests/test_main.c)
add_test(NAME tests COMMAND tests)

Uso:

mkdir build
cd build
cmake ..
make
./programa

Notas Finales¶

Sintaxis de Makefile

Regla básica:

target: dependencias
	comando

target: Archivo a generar
dependencias: Archivos necesarios
comando: Qué ejecutar (debe empezar con TAB)

Variables:

CC = gcc
CFLAGS = -Wall

$(CC) $(CFLAGS) programa.c

Variables automáticas:

$@: Target
$<: Primera dependencia
$^: Todas las dependencias
$*: Stem (parte que coincide con %)

Patrones:

%.o: %.c
	$(CC) -c $< -o $@

Errores Comunes

Olvidar include guard:

// Sin guard, múltiples inclusiones causan error
#ifndef HEADER_H
#define HEADER_H
// ...
#endif

Orden de enlazado:
```
# MAL
gcc -lm programa.c

# BIEN
gcc programa.c -lm
```
- Bibliotecas después de los archivos que las usan

Espacios en lugar de TAB en Makefile:

target:
    comando  # MAL: espacios
	comando  # BIEN: TAB

Incluir .c en vez de .h:

#include "modulo.c" // MAL
#include "modulo.h" // BIEN

Herramientas Útiles

Análisis:

cppcheck: Análisis estático
valgrind: Detección de memory leaks
gdb: Debugger
clang-format: Formateo automático

Build Systems:

make: Clásico, universal
cmake: Moderno, cross-platform
autotools: GNU standard (configure, make, make install)
ninja: Muy rápido

Comandos útiles:

1
2
3
4
5
6
7
8
9
10
11
# Ver símbolos en objeto
nm programa.o

# Ver bibliotecas dinámicas necesarias
ldd programa

# Ver tamaño de secciones
size programa

# Desensamblar
objdump -d programa.o

Estas consignas cubren compilación desde comandos básicos hasta proyectos complejos multi-archivo con automatización profesional.

Prerrequisitos y Entorno de Ejecución Requerido¶

Objetivos Pedagógicos y Competencias (Taxonomía de Bloom)¶

Capítulos de Apunte Correspondientes¶

Proyecto Multi-archivo Manual¶

Ejercicio 1.08.01 - Separar un programa en módulos ⭐⭐☆☆☆¶

Automatización con Makefile¶

Ejercicio 1.08.03 - Makefile básico ⭐☆☆☆☆¶

Compilación Condicional¶

Ejercicio 1.08.04 - Mensajes de depuración ⭐⭐☆☆☆¶

Ejercicio 1.08.06 - Warnings Habilitados ⭐☆☆☆☆¶

Ejercicio 1.08.07 - Verificación de Arquitectura en Tiempo de Compilación con _Static_assert ⭐⭐☆☆☆¶

Ejercicio 1.08.09 - Makefile Básico ⭐⭐⭐☆☆¶

Ejercicio 1.08.10 - Biblioteca Matemática ⭐⭐⭐☆☆¶

Ejercicio 1.08.11 - Flags de Optimización ⭐⭐⭐☆☆¶

Ejercicio 1.08.12 - Compilación Condicional ⭐⭐⭐☆☆¶

Ejercicio 1.08.13 - Módulo de Utilidades ⭐⭐⭐⭐☆¶

Ejercicio 1.08.14 - Makefile con Variables ⭐⭐⭐⭐☆¶

Ejercicio 1.08.15 - Dependencias Automáticas ⭐⭐⭐⭐☆¶

Ejercicio 1.08.16 - Biblioteca Estática ⭐⭐⭐⭐⭐¶

Ejercicio 1.08.17 - Biblioteca Compartida ⭐⭐⭐⭐⭐¶

Ejercicio 1.08.18 - Proyecto Multi-Directorio ⭐⭐⭐⭐⭐¶

Ejercicio 1.08.19 - Targets Adicionales ⭐⭐⭐⭐☆¶

Ejercicio 1.08.20 - Compilación Debug/Release ⭐⭐⭐⭐⭐¶

Ejercicio 1.08.21 - Análisis Estático ⭐⭐⭐⭐☆¶

Ejercicio 1.08.22 - Cross-Compilation ⭐⭐⭐⭐⭐¶

Ejercicio 1.08.23 - Sistema de Build Completo ⭐⭐⭐⭐⭐¶

Ejercicio 1.08.24 - CMake Básico ⭐⭐⭐⭐⭐¶

Notas Finales¶

Ejercicio 1.08.07 - Verificación de Arquitectura en Tiempo de Compilación con `_Static_assert` ⭐⭐☆☆☆¶