Ejercicios de enumeraciones - Programación 1

Acerca de¶

Estos ejercicios te permitirán practicar y consolidar el uso de enumeraciones (enum), estructuras (struct) y uniones (union) en C, desde conceptos básicos hasta aplicaciones avanzadas en el modelado de estados y la configuración de sistemas.

Para profundizar en los conceptos teóricos, podés consultar el siguiente capítulo del apunte:

Enumeraciones y Estructuras de Datos

Días de la Semana¶

Crear un tipo enum para representar los días de la semana y funciones básicas para trabajar con ellos.

1
2
3
4
5
6
7
8
9
enum dia_semana {
    LUNES,
    MARTES,
    MIERCOLES,
    JUEVES,
    VIERNES,
    SABADO,
    DOMINGO
};

Ejercicio 20.1 - Día siguiente ⭐⭐☆☆☆¶

Implementar una función que retorne el día siguiente al día proporcionado. El día siguiente a DOMINGO es LUNES.

enum dia_semana dia_siguiente(enum dia_semana dia_actual);

Ejercicio 20.2 - Es día laboral ⭐⭐☆☆☆¶

Implementar una función que determine si un día es laboral (lunes a viernes).

bool es_dia_laboral(enum dia_semana dia);

Ejercicio 20.3 - Nombre del día ⭐⭐☆☆☆¶

Implementar una función que retorne el nombre del día como cadena de texto. Esta función ilustra el patrón de conversión enum-a-string.

const char* nombre_dia(enum dia_semana dia);

Estados de Conexión¶

Modelar los estados de una conexión de red usando enumeraciones.

1
2
3
4
5
6
7
8
enum estado_red {
    DESCONECTADO,
    CONECTANDO,
    CONECTADO,
    DESCONECTANDO,
    ERROR_TIMEOUT,
    ERROR_AUTH
};

Ejercicio 20.4 - Máquina de estados ⭐⭐⭐☆☆¶

Implementar una función que procese transiciones de estado. La función debe recibir el estado actual y un evento, y retornar el nuevo estado según las reglas de transición.

1
2
3
4
5
6
7
8
enum evento_red {
    EVENTO_CONECTAR,
    EVENTO_DESCONECTAR,
    EVENTO_TIMEOUT,
    EVENTO_ERROR
};

enum estado_red procesar_evento(enum estado_red estado, enum evento_red evento);

Reglas de transición sugeridas:

DESCONECTADO + EVENTO_CONECTAR → CONECTANDO
CONECTANDO + EVENTO_TIMEOUT → ERROR_TIMEOUT
CONECTANDO + EVENTO_ERROR → ERROR_AUTH
CONECTADO + EVENTO_DESCONECTAR → DESCONECTANDO
DESCONECTANDO + transición completa → DESCONECTADO

Ejercicio 20.5 - Validación de estado ⭐⭐⭐☆☆¶

Implementar una función que valide si un valor numérico corresponde a un estado válido de la enumeración. Usar el patrón del valor centinela.

1
2
3
4
5
6
7
8
9
10
11
enum estado_red {
    DESCONECTADO,
    CONECTANDO,
    CONECTADO,
    DESCONECTANDO,
    ERROR_TIMEOUT,
    ERROR_AUTH,
    _ESTADO_MAX  // Valor centinela
};

bool estado_valido(int valor);

Sistema de Permisos con Flags¶

Implementar un sistema de permisos usando flags de bits. Este ejercicio demuestra cómo combinar múltiples opciones en un único valor.

1
2
3
4
5
6
enum permisos {
    PERMISO_LECTURA    = 1 << 0,  // 0x01
    PERMISO_ESCRITURA  = 1 << 1,  // 0x02
    PERMISO_EJECUCION  = 1 << 2,  // 0x04
    PERMISO_ELIMINAR   = 1 << 3   // 0x08
};

Ejercicio 20.6 - Verificar permiso ⭐⭐☆☆☆¶

Implementar una función que verifique si un conjunto de permisos incluye un permiso específico.

bool tiene_permiso(unsigned int permisos_actuales, enum permisos permiso);

Ejercicio 20.7 - Agregar y quitar permisos ⭐⭐☆☆☆¶

Implementar funciones para modificar el conjunto de permisos.

unsigned int agregar_permiso(unsigned int permisos, enum permisos nuevo);
unsigned int quitar_permiso(unsigned int permisos, enum permisos remover);

Ejercicio 20.8 - Listar permisos activos ⭐⭐☆☆☆¶

Implementar una función que imprima todos los permisos activos en un conjunto de permisos.

void mostrar_permisos(unsigned int permisos);

Colores RGB con Enum¶

Definir una enumeración para colores predefinidos y una estructura para representar colores RGB personalizados.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
enum color_predefinido {
    COLOR_NEGRO,
    COLOR_BLANCO,
    COLOR_ROJO,
    COLOR_VERDE,
    COLOR_AZUL,
    COLOR_AMARILLO,
    COLOR_MAGENTA,
    COLOR_CIAN
};

typedef struct {
    unsigned char r;
    unsigned char g;
    unsigned char b;
} rgb_t;

Ejercicio 20.9 - Conversión de color predefinido a RGB ⭐⭐☆☆☆¶

Implementar una función que convierta un color predefinido a sus componentes RGB.

rgb_t color_a_rgb(enum color_predefinido color);

Valores sugeridos:

COLOR_ROJO: (255, 0, 0)
COLOR_VERDE: (0, 255, 0)
COLOR_AZUL: (0, 0, 255)
COLOR_AMARILLO: (255, 255, 0)

Ejercicio 20.10 - Mezcla de colores ⭐⭐☆☆☆¶

Implementar una función que mezcle dos colores RGB usando promedio aritmético.

rgb_t mezclar_colores(rgb_t c1, rgb_t c2);

Configuración de Dispositivo con Unión Etiquetada¶

Implementar una unión etiquetada para almacenar diferentes tipos de configuración de dispositivos.

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
26
27
28
29
enum tipo_dispositivo {
    DISPOSITIVO_SENSOR_TEMP,
    DISPOSITIVO_MOTOR,
    DISPOSITIVO_LED
};

typedef struct {
    double temperatura_min;
    double temperatura_max;
} config_sensor_t;

typedef struct {
    unsigned int velocidad_rpm;
    bool direccion_horaria;
} config_motor_t;

typedef struct {
    unsigned char intensidad;
    enum color_predefinido color;
} config_led_t;

typedef struct {
    enum tipo_dispositivo tipo;
    union {
        config_sensor_t sensor;
        config_motor_t motor;
        config_led_t led;
    } config;
} dispositivo_t;

Ejercicio 20.11 - Configurar dispositivo ⭐⭐☆☆☆¶

Implementar funciones para configurar cada tipo de dispositivo de forma segura.

dispositivo_t crear_sensor(double temp_min, double temp_max);
dispositivo_t crear_motor(unsigned int rpm, bool horario);
dispositivo_t crear_led(unsigned char intensidad, enum color_predefinido color);

Ejercicio 20.12 - Imprimir configuración ⭐⭐☆☆☆¶

Implementar una función que imprima la configuración de un dispositivo según su tipo. Este ejercicio demuestra el uso correcto de uniones etiquetadas.

void imprimir_dispositivo(const dispositivo_t* dispositivo);

Códigos de Error¶

Definir una enumeración exhaustiva para códigos de error de un sistema.

1
2
3
4
5
6
7
8
9
10
enum codigo_error {
    ERROR_NINGUNO = 0,
    ERROR_MEMORIA,
    ERROR_ARCHIVO_NO_ENCONTRADO,
    ERROR_PERMISO_DENEGADO,
    ERROR_ARGUMENTO_INVALIDO,
    ERROR_TIMEOUT,
    ERROR_CONEXION,
    ERROR_DESCONOCIDO
};

Ejercicio 20.13 - Mensaje de error ⭐⭐☆☆☆¶

Implementar una función que retorne un mensaje descriptivo para cada código de error.

const char* mensaje_error(enum codigo_error error);

Ejercicio 20.14 - Tipo de resultado ⭐⭐⭐☆☆¶

Implementar un tipo resultado_t que encapsule un valor de retorno o un código de error usando unión etiquetada.

1
2
3
4
5
6
7
8
typedef struct {
    enum codigo_error error;
    union {
        int valor_int;
        double valor_double;
        void* valor_ptr;
    } datos;
} resultado_t;

Implementar funciones auxiliares:

resultado_t resultado_ok_int(int valor);
resultado_t resultado_error(enum codigo_error error);
bool resultado_es_error(const resultado_t* resultado);

Estados de Reproducción Multimedia¶

Modelar un reproductor multimedia con estados y modos de reproducción.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
enum estado_reproductor {
    ESTADO_DETENIDO,
    ESTADO_REPRODUCIENDO,
    ESTADO_PAUSADO,
    ESTADO_AVANZANDO,
    ESTADO_RETROCEDIENDO
};

enum modo_reproduccion {
    MODO_NORMAL,
    MODO_REPETIR_UNO,
    MODO_REPETIR_TODOS,
    MODO_ALEATORIO
};

Ejercicio 20.15 - Controlador de reproducción ⭐⭐☆☆☆¶

Implementar una estructura que encapsule el estado completo del reproductor.

1
2
3
4
5
6
typedef struct {
    enum estado_reproductor estado;
    enum modo_reproduccion modo;
    unsigned int pista_actual;
    unsigned int total_pistas;
} reproductor_t;

Ejercicio 20.16 - Comandos de control ⭐⭐☆☆☆¶

Implementar funciones para controlar el reproductor.

void reproducir(reproductor_t* rep);
void pausar(reproductor_t* rep);
void detener(reproductor_t* rep);
void siguiente_pista(reproductor_t* rep);
void anterior_pista(reproductor_t* rep);

Las funciones deben respetar el estado actual y el modo de reproducción.

Prioridades y Niveles de Log¶

Implementar un sistema de logging con niveles de prioridad.

1
2
3
4
5
6
7
enum nivel_log {
    LOG_DEBUG = 0,
    LOG_INFO,
    LOG_WARNING,
    LOG_ERROR,
    LOG_FATAL
};

Ejercicio 20.17 - Filtrado de logs ⭐⭐☆☆☆¶

Implementar una función que determine si un mensaje debe ser registrado según el nivel mínimo configurado.

bool debe_registrar(enum nivel_log nivel_mensaje, enum nivel_log nivel_minimo);

Ejercicio 20.18 - Formateo de mensaje de log ⭐⭐☆☆☆¶

Implementar una función que formatee un mensaje de log incluyendo el nivel como prefijo.

void log_mensaje(enum nivel_log nivel, const char* mensaje);

Ejemplo de salida: [ERROR] Archivo no encontrado

Protocolo de Comunicación¶

Diseñar estructuras para un protocolo simple de comunicación usando campos de bits.

1
2
3
4
5
6
7
8
9
10
11
12
enum tipo_mensaje {
    MSG_DATOS = 0,
    MSG_ACK = 1,
    MSG_NACK = 2,
    MSG_RESET = 3
};

typedef struct {
    unsigned int tipo : 2;        // 2 bits para tipo (0-3)
    unsigned int prioridad : 2;   // 2 bits para prioridad (0-3)
    unsigned int secuencia : 4;   // 4 bits para número de secuencia (0-15)
} cabecera_mensaje_t;

Ejercicio 20.19 - Crear y decodificar cabecera ⭐⭐☆☆☆¶

Implementar funciones para construir y extraer información de la cabecera.

cabecera_mensaje_t crear_cabecera(enum tipo_mensaje tipo, 
                                   unsigned int prioridad, 
                                   unsigned int secuencia);

void imprimir_cabecera(cabecera_mensaje_t cabecera);

Ejercicio 20.20 - Validación de cabecera ⭐⭐☆☆☆¶

Implementar una función que valide que los valores de una cabecera están dentro de los rangos permitidos.

bool cabecera_valida(cabecera_mensaje_t cabecera);

Opciones de Compilación con Flags¶

Modelar opciones de compilación como flags combinables.

1
2
3
4
5
6
7
8
enum opcion_compilacion {
    OPT_NINGUNA       = 0,
    OPT_OPTIMIZAR     = 1 << 0,  // -O
    OPT_DEBUG         = 1 << 1,  // -g
    OPT_WARNINGS      = 1 << 2,  // -Wall
    OPT_WARNINGS_EXTRA = 1 << 3, // -Wextra
    OPT_PEDANTIC      = 1 << 4   // -pedantic
};

Ejercicio 20.21 - Generar línea de comandos ⭐⭐☆☆☆¶

Implementar una función que genere una cadena con las opciones de compilación correspondientes a los flags activos.

void generar_comando_compilacion(unsigned int opciones, char* buffer, size_t tam);

Ejemplo: Si opciones tiene OPT_DEBUG | OPT_WARNINGS, el buffer debe contener "-g -Wall".

Ejercicio 20.22 - Detectar conflictos ⭐⭐☆☆☆¶

Implementar una función que detecte combinaciones incompatibles de opciones.

bool opciones_compatibles(unsigned int opciones);

Por ejemplo, OPT_OPTIMIZAR y OPT_DEBUG podrían considerarse incompatibles en ciertos contextos.

Menú de Aplicación¶

Implementar un sistema de menú interactivo usando enumeraciones.

1
2
3
4
5
6
7
8
enum opcion_menu {
    MENU_NUEVO = 1,
    MENU_ABRIR,
    MENU_GUARDAR,
    MENU_CERRAR,
    MENU_SALIR,
    MENU_INVALIDO = -1
};

Ejercicio 20.23 - Parser de opción ⭐⭐☆☆☆¶

Implementar una función que convierta la entrada del usuario en una opción del menú.

enum opcion_menu parsear_opcion(int entrada);

Ejercicio 20.24 - Ejecutor de menú ⭐⭐☆☆☆¶

Implementar una función que ejecute la acción correspondiente a cada opción del menú.

void ejecutar_opcion(enum opcion_menu opcion);

Ejercicio 20.25 - Menú interactivo completo ⭐⭐☆☆☆¶

Implementar un lazo principal que muestre el menú, lea la opción del usuario y ejecute la acción hasta que el usuario seleccione MENU_SALIR.

Tipos de Figuras Geométricas con Unión¶

Combinar enumeraciones, estructuras y uniones para representar diferentes figuras geométricas.

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
26
27
28
29
enum tipo_figura {
    FIGURA_CIRCULO,
    FIGURA_RECTANGULO,
    FIGURA_TRIANGULO
};

typedef struct {
    double radio;
} circulo_t;

typedef struct {
    double base;
    double altura;
} rectangulo_t;

typedef struct {
    double lado_a;
    double lado_b;
    double lado_c;
} triangulo_t;

typedef struct {
    enum tipo_figura tipo;
    union {
        circulo_t circulo;
        rectangulo_t rectangulo;
        triangulo_t triangulo;
    } datos;
} figura_t;

Ejercicio 20.26 - Cálculo de área ⭐⭐☆☆☆¶

Implementar una función que calcule el área de cualquier figura usando su tipo y datos.

double calcular_area(const figura_t* figura);

Fórmulas:

Círculo: $A = \pi r^2$
Rectángulo: $A = base \times altura$
Triángulo (Fórmula de Herón):
- $s = \frac{a+b+c}{2}$
- $A = \sqrt{s(s-a)(s-b)(s-c)}$

Ejercicio 20.27 - Constructores de figuras ⭐⭐⭐☆☆¶

Implementar funciones para crear cada tipo de figura de forma segura.

figura_t crear_circulo(double radio);
figura_t crear_rectangulo(double base, double altura);
figura_t crear_triangulo(double a, double b, double c);

Conversión entre Enums y Strings¶

Ejercicio 20.28 - Tabla de conversión ⭐⭐☆☆☆¶

Implementar un sistema genérico para convertir entre valores enum y strings usando tablas de conversión.

1
2
3
4
5
6
7
8
9
10
11
12
typedef struct {
    int valor;
    const char* nombre;
} enum_string_t;

// Ejemplo de uso con días de la semana
const enum_string_t tabla_dias[] = {
    {LUNES, "Lunes"},
    {MARTES, "Martes"},
    {MIERCOLES, "Miércoles"},
    // ...
};

Ejercicio 20.29 - Funciones de conversión genéricas ⭐⭐☆☆☆¶

Implementar funciones genéricas que usen la tabla para realizar conversiones.

const char* enum_a_string(int valor, const enum_string_t* tabla, size_t tam);
int string_a_enum(const char* nombre, const enum_string_t* tabla, size_t tam, int valor_defecto);

Estado de Juego¶

Modelar el estado de un juego simple usando múltiples enumeraciones.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
enum estado_juego {
    JUEGO_MENU,
    JUEGO_JUGANDO,
    JUEGO_PAUSADO,
    JUEGO_GAME_OVER,
    JUEGO_VICTORIA
};

enum dificultad {
    DIFICULTAD_FACIL,
    DIFICULTAD_NORMAL,
    DIFICULTAD_DIFICIL,
    DIFICULTAD_EXPERTO
};

typedef struct {
    enum estado_juego estado;
    enum dificultad dificultad;
    unsigned int puntuacion;
    unsigned int nivel;
    unsigned int vidas;
} juego_t;

Ejercicio 20.30 - Inicializar juego ⭐☆☆☆☆¶

Implementar una función que inicialice un juego nuevo con la dificultad especificada.

juego_t inicializar_juego(enum dificultad dif);

La dificultad debe afectar el número inicial de vidas y otros parámetros.

Ejercicio 20.31 - Gestión de estado ⭐⭐⭐☆☆¶

Implementar funciones para transiciones de estado comunes.

void pausar_juego(juego_t* juego);
void reanudar_juego(juego_t* juego);
void perder_vida(juego_t* juego);
void ganar_nivel(juego_t* juego);

Análisis de Tráfico con Enums Aninados¶

Modelar un sistema de análisis de tráfico de red con múltiples niveles de clasificación.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
enum protocolo {
    PROTOCOLO_TCP,
    PROTOCOLO_UDP,
    PROTOCOLO_ICMP,
    PROTOCOLO_OTRO
};

enum tipo_trafico {
    TRAFICO_NORMAL,
    TRAFICO_SOSPECHOSO,
    TRAFICO_MALICIOSO
};

typedef struct {
    enum protocolo proto;
    enum tipo_trafico tipo;
    unsigned int puerto_origen;
    unsigned int puerto_destino;
    size_t bytes_transferidos;
} paquete_red_t;

Ejercicio 20.32 - Clasificador de tráfico ⭐⭐☆☆☆¶

Implementar una función que clasifique un paquete basándose en reglas heurísticas.

enum tipo_trafico clasificar_paquete(const paquete_red_t* paquete);

Reglas sugeridas:

Puertos conocidos (80, 443, 22) → TRAFICO_NORMAL
Puertos altos no estándar → TRAFICO_SOSPECHOSO
Transferencias muy grandes o patrones anómalos → TRAFICO_MALICIOSO

Ejercicio 20.33 - Estadísticas por protocolo ⭐⭐⭐☆☆¶

Implementar una función que cuente paquetes por protocolo en un arreglo de paquetes.

1
2
3
4
5
6
7
8
typedef struct {
    unsigned int tcp;
    unsigned int udp;
    unsigned int icmp;
    unsigned int otro;
} estadisticas_protocolo_t;

estadisticas_protocolo_t contar_por_protocolo(const paquete_red_t* paquetes, size_t cantidad);

Enums en Sistemas de Archivos¶

Ejercicio 20.34 - Permisos de archivo (UNIX) ⭐⭐☆☆☆¶

Modelar permisos de archivo estilo UNIX usando flags.

1
2
3
4
5
6
7
8
9
10
11
enum permiso_unix {
    OWNER_READ    = 0400,  // 0100000000 en octal
    OWNER_WRITE   = 0200,
    OWNER_EXECUTE = 0100,
    GROUP_READ    = 0040,
    GROUP_WRITE   = 0020,
    GROUP_EXECUTE = 0010,
    OTHER_READ    = 0004,
    OTHER_WRITE   = 0002,
    OTHER_EXECUTE = 0001
};

Implementar funciones para manipular permisos:

bool tiene_permiso_unix(unsigned int permisos, enum permiso_unix permiso);
unsigned int agregar_permiso_unix(unsigned int permisos, enum permiso_unix nuevo);
void mostrar_permisos_unix(unsigned int permisos);  // Formato: rwxr-xr--

Ejercicio 20.35 - Tipos de archivo ⭐⭐☆☆☆¶

Modelar diferentes tipos de archivo en un sistema de archivos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
enum tipo_archivo {
    TIPO_REGULAR,
    TIPO_DIRECTORIO,
    TIPO_ENLACE_SIMBOLICO,
    TIPO_ENLACE_DURO,
    TIPO_DISPOSITIVO,
    TIPO_PIPE,
    TIPO_SOCKET
};

typedef struct {
    char nombre[256];
    enum tipo_archivo tipo;
    size_t tamanio;
    unsigned int permisos;
} archivo_info_t;

Sistema de Eventos¶

Ejercicio 20.36 - Tipos de eventos de UI ⭐⭐☆☆☆¶

Modelar eventos de interfaz de usuario.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
enum tipo_evento {
    EVENTO_CLICK,
    EVENTO_DOBLE_CLICK,
    EVENTO_PRESIONAR_TECLA,
    EVENTO_SOLTAR_TECLA,
    EVENTO_MOVER_MOUSE,
    EVENTO_SCROLL
};

enum boton_mouse {
    BOTON_IZQUIERDO = 1,
    BOTON_DERECHO = 2,
    BOTON_MEDIO = 4
};

typedef struct {
    enum tipo_evento tipo;
    int x, y;  // Coordenadas
    unsigned int botones;  // Flags de botones presionados
    unsigned int tecla;
} evento_t;

Ejercicio 20.37 - Procesador de eventos ⭐⭐☆☆☆¶

Implementar un procesador que maneje diferentes tipos de eventos.

void procesar_evento(const evento_t* evento);

Estados de Procesos (Sistema Operativo)¶

Ejercicio 20.38 - Modelo de estados ⭐⭐⭐☆☆¶

Modelar el ciclo de vida de un proceso en un sistema operativo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
enum estado_proceso {
    PROCESO_NUEVO,
    PROCESO_LISTO,
    PROCESO_EJECUTANDO,
    PROCESO_BLOQUEADO,
    PROCESO_TERMINADO
};

enum razon_bloqueo {
    BLOQ_IO,
    BLOQ_MUTEX,
    BLOQ_SEMAFORO,
    BLOQ_MENSAJE
};

typedef struct {
    int pid;
    enum estado_proceso estado;
    enum razon_bloqueo razon;  // Solo válido si estado == BLOQUEADO
    int prioridad;
} proceso_t;

Ejercicio 20.39 - Planificador simple ⭐☆☆☆☆¶

Implementar funciones de transición de estado para un planificador.

bool transicion_estado(proceso_t* proceso, enum estado_proceso nuevo_estado);
bool puede_ejecutar(const proceso_t* proceso);

Protocolo HTTP¶

Ejercicio 20.40 - Métodos y códigos HTTP ⭐⭐☆☆☆¶

Modelar métodos y códigos de estado HTTP.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
enum metodo_http {
    HTTP_GET,
    HTTP_POST,
    HTTP_PUT,
    HTTP_DELETE,
    HTTP_PATCH,
    HTTP_HEAD,
    HTTP_OPTIONS
};

enum codigo_http {
    HTTP_200_OK = 200,
    HTTP_201_CREATED = 201,
    HTTP_204_NO_CONTENT = 204,
    HTTP_301_MOVED = 301,
    HTTP_302_FOUND = 302,
    HTTP_400_BAD_REQUEST = 400,
    HTTP_401_UNAUTHORIZED = 401,
    HTTP_403_FORBIDDEN = 403,
    HTTP_404_NOT_FOUND = 404,
    HTTP_500_INTERNAL_ERROR = 500,
    HTTP_503_UNAVAILABLE = 503
};

Ejercicio 20.41 - Parser de respuesta HTTP ⭐⭐☆☆☆¶

Implementar funciones para trabajar con HTTP.

const char* metodo_a_string(enum metodo_http metodo);
const char* codigo_a_mensaje(enum codigo_http codigo);
bool es_codigo_exito(enum codigo_http codigo);  // 2xx
bool es_codigo_error_cliente(enum codigo_http codigo);  // 4xx
bool es_codigo_error_servidor(enum codigo_http codigo);  // 5xx

Semáforo (Sistema de Control)¶

Ejercicio 20.42 - Estados de semáforo ⭐⭐⭐☆☆¶

Modelar un sistema de semáforo de tráfico.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
enum estado_semaforo {
    SEMAFORO_ROJO,
    SEMAFORO_AMARILLO,
    SEMAFORO_VERDE,
    SEMAFORO_INTERMITENTE
};

enum direccion_trafico {
    DIR_NORTE_SUR,
    DIR_ESTE_OESTE,
    DIR_TODAS
};

typedef struct {
    enum estado_semaforo estado;
    enum direccion_trafico direccion_activa;
    int tiempo_restante;  // Segundos
} semaforo_t;

Ejercicio 20.43 - Controlador de semáforo ⭐⭐☆☆☆¶

Implementar la lógica de transición de un semáforo.

void actualizar_semaforo(semaforo_t* semaforo);
enum estado_semaforo siguiente_estado(enum estado_semaforo actual);
bool puede_pasar(const semaforo_t* semaforo, enum direccion_trafico direccion);

Transacciones de Base de Datos¶

Ejercicio 20.44 - Estados de transacción ⭐⭐⭐☆☆¶

Modelar el ciclo de vida de una transacción.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
enum estado_transaccion {
    TX_INICIADA,
    TX_ACTIVA,
    TX_PREPARADA,
    TX_COMPROMETIDA,
    TX_ABORTADA
};

enum tipo_aislamiento {
    AISLAMIENTO_READ_UNCOMMITTED,
    AISLAMIENTO_READ_COMMITTED,
    AISLAMIENTO_REPEATABLE_READ,
    AISLAMIENTO_SERIALIZABLE
};

typedef struct {
    unsigned long id;
    enum estado_transaccion estado;
    enum tipo_aislamiento aislamiento;
    int num_operaciones;
} transaccion_t;

Ejercicio 20.45 - Gestor de transacciones ⭐⭐☆☆☆¶

Implementar funciones para gestionar transacciones.

transaccion_t iniciar_transaccion(enum tipo_aislamiento aislamiento);
bool commit_transaccion(transaccion_t* tx);
bool rollback_transaccion(transaccion_t* tx);
bool puede_hacer_commit(const transaccion_t* tx);

Tipos de Datos SQL¶

Ejercicio 20.46 - Tipos de columna ⭐⭐☆☆☆¶

Modelar tipos de datos SQL y sus propiedades.

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
26
27
28
enum tipo_sql {
    SQL_INT,
    SQL_BIGINT,
    SQL_FLOAT,
    SQL_DOUBLE,
    SQL_VARCHAR,
    SQL_TEXT,
    SQL_DATE,
    SQL_DATETIME,
    SQL_BOOLEAN,
    SQL_BLOB
};

enum constraint_sql {
    CONSTRAINT_NINGUNO     = 0,
    CONSTRAINT_NOT_NULL    = 1 << 0,
    CONSTRAINT_UNIQUE      = 1 << 1,
    CONSTRAINT_PRIMARY_KEY = 1 << 2,
    CONSTRAINT_FOREIGN_KEY = 1 << 3,
    CONSTRAINT_AUTO_INCREMENT = 1 << 4
};

typedef struct {
    char nombre[64];
    enum tipo_sql tipo;
    unsigned int constraints;
    int longitud;  // Para VARCHAR
} columna_t;

Ejercicio 20.47 - Validación de columnas ⭐⭐☆☆☆¶

Implementar funciones para validar definiciones de columnas.

bool es_tipo_numerico(enum tipo_sql tipo);
bool es_tipo_texto(enum tipo_sql tipo);
bool constraints_validos(unsigned int constraints);
size_t tamanio_tipo(enum tipo_sql tipo);

Formatos de Imagen¶

Ejercicio 20.48 - Tipos y formatos ⭐⭐☆☆☆¶

Modelar diferentes formatos de imagen y sus propiedades.

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
26
27
enum formato_imagen {
    FORMATO_JPEG,
    FORMATO_PNG,
    FORMATO_GIF,
    FORMATO_BMP,
    FORMATO_WEBP,
    FORMATO_TIFF,
    FORMATO_SVG
};

enum modo_color {
    COLOR_ESCALA_GRISES,
    COLOR_RGB,
    COLOR_RGBA,
    COLOR_CMYK,
    COLOR_INDEXADO
};

typedef struct {
    enum formato_imagen formato;
    enum modo_color modo;
    int ancho;
    int alto;
    int profundidad_bits;
    bool tiene_transparencia;
    bool es_animado;
} metadata_imagen_t;

Ejercicio 20.49 - Análisis de formatos ⭐⭐☆☆☆¶

Implementar funciones para analizar propiedades de formatos.

bool soporta_transparencia(enum formato_imagen formato);
bool soporta_animacion(enum formato_imagen formato);
bool es_formato_comprimido(enum formato_imagen formato);
const char* extension_formato(enum formato_imagen formato);

Sistema de Notificaciones¶

Ejercicio 20.50 - Niveles de notificación ⭐⭐☆☆☆¶

Modelar un sistema de notificaciones con prioridades.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
enum nivel_notificacion {
    NOTIF_DEBUG,
    NOTIF_INFO,
    NOTIF_ADVERTENCIA,
    NOTIF_ERROR,
    NOTIF_CRITICO
};

enum canal_notificacion {
    CANAL_NINGUNO  = 0,
    CANAL_CONSOLE  = 1 << 0,
    CANAL_EMAIL    = 1 << 1,
    CANAL_SMS      = 1 << 2,
    CANAL_PUSH     = 1 << 3,
    CANAL_SYSLOG   = 1 << 4
};

typedef struct {
    enum nivel_notificacion nivel;
    unsigned int canales;
    char mensaje[256];
    time_t timestamp;
} notificacion_t;

Ejercicio 20.51 - Gestor de notificaciones ⭐⭐☆☆☆¶

Implementar funciones para filtrar y enviar notificaciones.

void enviar_notificacion(const notificacion_t* notif);
bool debe_notificar(enum nivel_notificacion nivel, enum nivel_notificacion nivel_minimo);
unsigned int canales_para_nivel(enum nivel_notificacion nivel);

Compresión de Datos¶

Ejercicio 20.52 - Algoritmos de compresión ⭐⭐☆☆☆¶

Modelar diferentes algoritmos de compresión y sus niveles.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
enum algoritmo_compresion {
    COMP_NINGUNO,
    COMP_DEFLATE,
    COMP_GZIP,
    COMP_BZIP2,
    COMP_LZMA,
    COMP_ZSTD,
    COMP_LZ4
};

enum nivel_compresion {
    NIVEL_MINIMO = 1,
    NIVEL_RAPIDO = 3,
    NIVEL_NORMAL = 5,
    NIVEL_MAXIMO = 9
};

typedef struct {
    enum algoritmo_compresion algoritmo;
    enum nivel_compresion nivel;
    size_t tamanio_original;
    size_t tamanio_comprimido;
    double ratio;  // tamanio_comprimido / tamanio_original
} resultado_compresion_t;

Ejercicio 20.53 - Análisis de compresión ⭐⭐☆☆☆¶

Implementar funciones para analizar rendimiento de compresión.

double calcular_ratio(const resultado_compresion_t* resultado);
double porcentaje_ahorro(const resultado_compresion_t* resultado);
bool es_algoritmo_rapido(enum algoritmo_compresion alg);
const char* nombre_algoritmo(enum algoritmo_compresion alg);

Máquina de Estados Finita Genérica¶

Ejercicio 20.54 - Framework de FSM ⭐⭐☆☆☆¶

Implementar un framework genérico para máquinas de estados finitas.

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
26
27
28
29
30
31
#define MAX_ESTADOS 32
#define MAX_TRANSICIONES 64

typedef enum {
    FSM_ESTADO_0,
    FSM_ESTADO_1,
    FSM_ESTADO_2,
    // ... más estados
    FSM_ESTADO_MAX
} estado_fsm_t;

typedef enum {
    FSM_EVENTO_0,
    FSM_EVENTO_1,
    // ... más eventos
    FSM_EVENTO_MAX
} evento_fsm_t;

typedef struct {
    estado_fsm_t desde;
    estado_fsm_t hasta;
    evento_fsm_t evento;
    void (*accion)(void* contexto);
} transicion_t;

typedef struct {
    estado_fsm_t estado_actual;
    transicion_t transiciones[MAX_TRANSICIONES];
    int num_transiciones;
    void* contexto;
} maquina_estados_t;

Ejercicio 20.55 - Motor de FSM ⭐⭐☆☆☆¶

Implementar el motor que procesa eventos y ejecuta transiciones.

void fsm_inicializar(maquina_estados_t* fsm, estado_fsm_t inicial);
bool fsm_agregar_transicion(maquina_estados_t* fsm, transicion_t trans);
bool fsm_procesar_evento(maquina_estados_t* fsm, evento_fsm_t evento);
estado_fsm_t fsm_estado_actual(const maquina_estados_t* fsm);

Análisis Comparativo de Enums¶

Ejercicio 20.56 - Comparación de implementaciones ⭐⭐☆☆☆¶

Analizar diferentes formas de implementar el mismo concepto:

Opción 1: Enum simple

enum dia { LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO };

Opción 2: Enum con valores explícitos

enum dia { LUNES=1, MARTES=2, MIERCOLES=3, JUEVES=4, VIERNES=5, SABADO=6, DOMINGO=7 };

Opción 3: Flags con potencias de 2

enum dia { 
    LUNES=1<<0, MARTES=1<<1, MIERCOLES=1<<2, JUEVES=1<<3, 
    VIERNES=1<<4, SABADO=1<<5, DOMINGO=1<<6 
};

Discutir casos de uso, ventajas y desventajas de cada enfoque.

Ejercicio 20.57 - Tamaño y rendimiento ⭐⭐☆☆☆¶

Investigar y documentar:

Tamaño en memoria de enums (usualmente sizeof(int))
Rendimiento de operaciones con enums vs constantes
Optimizaciones del compilador con enums
Diferencias entre C y C++ en el manejo de enums

Ejercicio 20.58 - Enumeración de Días ⭐☆☆☆☆¶

Definí una enumeración para días de la semana y mostrá el nombre según el valor.

Orientación:

typedef enum {
    LUNES, MARTES, MIERCOLES, JUEVES, 
    VIERNES, SABADO, DOMINGO
} dia_semana_t;

Usá switch para convertir enum a string

Ejercicio 20.59 - Estructura Punto 2D ⭐☆☆☆☆¶

Definí estructura para punto en 2D y función para calcular distancia entre dos puntos.

Orientación:

typedef struct {
    double x;
    double y;
} punto_t;

Distancia: sqrt((p2.x - p1.x)² + (p2.y - p1.y)²)

Ejercicio 20.60 - Estructura Fecha ⭐⭐☆☆☆¶

Creá estructura para fecha y función de validación.

Orientación:

typedef struct {
    int dia;
    int mes;
    int anio;
} fecha_t;

Validar: 1 ≤ mes ≤ 12, día según mes, considerar bisiestos

Ejercicio 20.61 - Estructura Persona ⭐⭐☆☆☆¶

Definí estructura persona y función para mostrar información.

Orientación:

typedef struct {
    char nombre[50];
    char apellido[50];
    int edad;
} persona_t;

Función void mostrar_persona(const persona_t *p)

Ejercicio 20.62 - Array de Estructuras ⭐⭐⭐☆☆¶

Creá array de estudiantes y función para encontrar el de mayor promedio.

Orientación:

typedef struct {
    char nombre[50];
    float promedio;
} estudiante_t;

estudiante_t clase[30];

Recorré array comparando promedios

Ejercicio 20.63 - Enumeración con Valores Explícitos ⭐⭐☆☆☆¶

Definí enumeración para códigos de error HTTP.

Orientación:

1
2
3
4
5
6
7
typedef enum {
    HTTP_OK = 200,
    HTTP_CREATED = 201,
    HTTP_BAD_REQUEST = 400,
    HTTP_NOT_FOUND = 404,
    HTTP_SERVER_ERROR = 500
} http_status_t;

Ejercicio 20.64 - Estructura Anidada ⭐⭐⭐☆☆¶

Creá estructura para dirección y persona que incluya dirección.

Orientación:

1
2
3
4
5
6
7
8
9
10
typedef struct {
    char calle[100];
    int numero;
    char ciudad[50];
} direccion_t;

typedef struct {
    char nombre[50];
    direccion_t direccion;  // Estructura anidada
} persona_t;

Ejercicio 20.65 - Estructura con Puntero ⭐⭐⭐☆☆¶

Definí estructura nodo para lista enlazada.

Orientación:

typedef struct nodo {
    int dato;
    struct nodo *siguiente;  // Puntero a mismo tipo
} nodo_t;

Funciones: crear_nodo, insertar_inicio, mostrar_lista

Ejercicio 20.66 - Union para Tipos Múltiples ⭐⭐⭐☆☆¶

Usá union para almacenar valor que puede ser int, float o char.

Orientación:

1
2
3
4
5
6
7
8
9
10
typedef enum { TIPO_INT, TIPO_FLOAT, TIPO_CHAR } tipo_t;

typedef struct {
    tipo_t tipo;
    union {
        int i;
        float f;
        char c;
    } valor;
} variable_t;

El tipo indica cuál campo de la union es válido

Ejercicio 20.67 - Inicialización Designada ⭐⭐☆☆☆¶

Practicá diferentes formas de inicializar estructuras.

Orientación:

1
2
3
4
5
6
7
8
9
// Orden
punto_t p1 = {3.0, 4.0};

// Designadores (C99)
punto_t p2 = {.x = 3.0, .y = 4.0};
punto_t p3 = {.y = 4.0, .x = 3.0};  // Orden no importa

// Parcial (resto en 0)
punto_t p4 = {.x = 3.0};

Ejercicio 20.68 - Rectángulo con Puntos ⭐⭐⭐☆☆¶

Definí rectángulo con dos puntos (esquinas opuestas) y calcula área/perímetro.

Orientación:

typedef struct {
    punto_t superior_izq;
    punto_t inferior_der;
} rectangulo_t;

Área: ancho × alto
Perímetro: 2 × (ancho + alto)

Ejercicio 20.69 - Biblioteca de Libros ⭐⭐⭐⭐☆¶

Sistema con estructuras para libro, autor, editorial.

Orientación:

1
2
3
4
5
6
7
8
9
10
11
typedef struct {
    char nombre[50];
    int anio_nacimiento;
} autor_t;

typedef struct {
    char titulo[100];
    autor_t autor;
    int anio_publicacion;
    float precio;
} libro_t;

Funciones: buscar por título, filtrar por autor, ordenar por precio

Ejercicio 20.70 - Enum como Flags (Bits) ⭐⭐⭐⭐☆¶

Usá enum para permisos de archivo estilo Unix.

Orientación:

1
2
3
4
5
6
7
8
9
10
11
typedef enum {
    PERM_READ    = 1 << 0,  // 0001
    PERM_WRITE   = 1 << 1,  // 0010
    PERM_EXECUTE = 1 << 2,  // 0100
} permisos_t;

// Combinar permisos con OR
int permisos = PERM_READ | PERM_WRITE;

// Verificar con AND
if (permisos & PERM_READ) { /* tiene lectura */ }

Ejercicio 20.71 - Struct con Padding ⭐⭐⭐⭐☆¶

Explorá alineación de memoria en estructuras.

Orientación:

1
2
3
4
5
6
7
8
9
10
11
typedef struct {
    char c;    // 1 byte + 3 padding
    int i;     // 4 bytes
    char d;    // 1 byte + 3 padding
} mal_alineada_t;  // Total: 12 bytes

typedef struct {
    int i;     // 4 bytes
    char c;    // 1 byte
    char d;    // 1 byte + 2 padding
} bien_alineada_t;  // Total: 8 bytes

Usá sizeof() para ver diferencias

Ejercicio 20.72 - Árbol Binario ⭐⭐⭐⭐⭐¶

Implementá estructura de árbol binario y recorridos.

Orientación:

typedef struct nodo_arbol {
    int dato;
    struct nodo_arbol *izquierdo;
    struct nodo_arbol *derecho;
} nodo_arbol_t;

Funciones: insertar, buscar, recorridos (inorden, preorden, postorden)

Ejercicio 20.73 - Polimorfismo con Union ⭐⭐⭐⭐⭐¶

Creá sistema de figuras geométricas con union.

Orientación:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
typedef enum { CIRCULO, RECTANGULO, TRIANGULO } tipo_figura_t;

typedef struct {
    punto_t centro;
    double radio;
} circulo_t;

typedef struct {
    punto_t p1, p2;
} rectangulo_t;

typedef struct {
    tipo_figura_t tipo;
    union {
        circulo_t circulo;
        rectangulo_t rectangulo;
    } datos;
} figura_t;

double calcular_area(const figura_t *f);

Ejercicio 20.74 - Cola con Struct ⭐⭐⭐⭐☆¶

Implementá cola FIFO con estructura.

Orientación:

1
2
3
4
5
6
7
typedef struct {
    int *datos;
    int frente;
    int fin;
    int capacidad;
    int tamanio;
} cola_t;

Funciones: crear, encolar, desencolar, esta_llena, destruir

Ejercicio 20.75 - Grafo con Listas de Adyacencia ⭐⭐⭐⭐⭐¶

Representá grafo con estructuras.

Orientación:

1
2
3
4
5
6
7
8
9
typedef struct nodo_lista {
    int vertice;
    struct nodo_lista *siguiente;
} nodo_lista_t;

typedef struct {
    int num_vertices;
    nodo_lista_t **listas_adyacencia;
} grafo_t;

Funciones: crear_grafo, agregar_arista, mostrar

Ejercicio 20.76 - Base de Datos Simple ⭐⭐⭐⭐⭐¶

Sistema CRUD para empleados.

Orientación:

1
2
3
4
5
6
7
8
9
10
11
12
typedef struct {
    int id;
    char nombre[50];
    char departamento[50];
    float salario;
} empleado_t;

typedef struct {
    empleado_t *empleados;
    int cantidad;
    int capacidad;
} base_datos_t;

Funciones: crear, agregar, buscar, actualizar, eliminar, listar

Ejercicio 20.77 - Máquina de Estados con Enum ⭐⭐⭐⭐⭐¶

Implementá máquina de estados finitos.

Orientación:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
typedef enum {
    ESTADO_INICIO,
    ESTADO_PROCESANDO,
    ESTADO_PAUSA,
    ESTADO_ERROR,
    ESTADO_FIN
} estado_t;

typedef enum {
    EVENTO_INICIAR,
    EVENTO_PAUSAR,
    EVENTO_REANUDAR,
    EVENTO_ERROR,
    EVENTO_COMPLETAR
} evento_t;

typedef struct {
    estado_t estado_actual;
    // Datos del contexto
} maquina_t;

estado_t transicion(estado_t actual, evento_t evento);

Notas Finales¶

Convenciones de Nomenclatura

Enumeraciones:

typedef enum {
    COLOR_ROJO,
    COLOR_VERDE,
    COLOR_AZUL
} color_t;

Sufijo _t para el tipo
Prefijo común para los valores

Estructuras:

typedef struct {
    // campos
} nombre_t;

Sufijo _t indica que es un tipo definido por el usuario

Tamaño y Alineación

Obtener tamaño:

printf("Tamaño: %zu bytes\n", sizeof(estructura_t));

Offset de campos:

#include <stddef.h>
printf("Offset de campo: %zu\n", offsetof(estructura_t, campo));

Alineación:

Campos se alinean a múltiplos de su tamaño
Estructura completa se alinea al mayor campo
Reordenar campos puede ahorrar memoria

Errores Comunes

Olvidar typedef:

struct punto { int x, y; };
struct punto p;  // Necesitas "struct"

typedef struct { int x, y; } punto_t;
punto_t p;  // Más limpio

Union sin tipo discriminador:

// MAL: no sabés qué campo es válido
union { int i; float f; } valor;

// BIEN: con tipo
struct {
    enum { INT, FLOAT } tipo;
    union { int i; float f; } valor;
} variable;

Comparación de structs:

// MAL: no se puede comparar directamente
if (p1 == p2) { }

// BIEN: comparar campo por campo
if (p1.x == p2.x && p1.y == p2.y) { }

Copiar structs con punteros:

typedef struct {
    char *nombre;  // Puntero
} persona_t;

persona_t p2 = p1;  // Copia shallow: ambos apuntan al mismo nombre
// Necesitas copia profunda manual

Inicialización

Cero:

estructura_t s = {0};  // Todo en cero

Designadores C99:

punto_t p = {
    .x = 10,
    .y = 20
};

Compuesta (C99):

punto_t p = (punto_t){.x = 10, .y = 20};

Array de structs:

punto_t puntos[] = {
    {1, 2},
    {3, 4},
    {.x = 5, .y = 6}
};

Estructuras Opacas

Encapsulamiento:

1
2
3
4
5
6
7
8
9
// archivo.h
typedef struct archivo archivo_t;  // Declaración opaca
archivo_t *abrir_archivo(const char *ruta);

// archivo.c
struct archivo {  // Definición oculta
    FILE *fp;
    int linea;
};

Usuario solo ve puntero, no puede acceder a campos
Facilita cambios internos sin romper código cliente

Estas consignas cubren tipos de datos personalizados desde básicos hasta sistemas complejos, preparando para diseño de TADs profesionales.