Cursus — C-piscine-reloaded

El puente entre la piscine y el cursus: 28 ejercicios que recorren en un día lo que la piscine contó en un mes — shell, bucles, punteros, cadenas, malloc, macros, structs, punteros a función, un Makefile y un programa que lee ficheros. Casi todo ya salió en la piscine, así que aquí se va rápido por lo repetido y se para en lo que importa para lo que viene: compilar una librería y hablar con el sistema de ficheros.

Qué es la Piscine Reloaded — Es el proyecto con el que arranca el cursus: un "recopilatorio de los mejores ejercicios" de la C Piscine (así lo llama el enunciado, cuyo subtítulo es un muy poco solemne "Eeey, tamo' de vueltaaa..."). No añade temas nuevos; su función es que vuelvas a escribir de memoria lo básico antes de Libft, y el enunciado pide expresamente no rescatar el código antiguo de la piscine. Lo corrige solo la Moulinette, con cc -Wall -Wextra -Werror y la norminette, y los ejercicios están ordenados: uno complejo no cuenta si falla uno anterior. Un detalle de reglas que se nota en todo el código: cuando la función autorizada es ft_putchar, la Moulinette compila con su propio ft_putchar.c. Por eso los ficheros solo declaran el prototipo (void ft_putchar(char a);) y no lo definen: si lo definieran, habría dos definiciones y el enlazador fallaría. (El preámbulo es una biografía de Edward Snowden, y recomienda el documental Citizenfour; no tiene que ver con los ejercicios.)

GGlosario de teoría

La Piscine Reloaded repasa en 28 ejercicios casi todo lo básico de Unix y de C, así que la página usa muchas palabras técnicas. Aquí está cada una explicada desde cero y con un ejemplo sacado del propio proyecto. En el resto de la página, la primera vez que sale uno de estos términos en cada tarjeta lleva un enlace a su entrada.

Ficheros y shell

Permisos (rwx)

Cada fichero tiene tres grupos de tres permisos: para el dueño, para su grupo y para el resto. r es leer, w escribir y x ejecutar (en un directorio, x es poder entrar en él). Cada grupo se escribe también como una cifra octal sumando r = 4, w = 2 y x = 1.

En el ex00, test1 es -rwx--xr--: el dueño todo (7), el grupo solo ejecutar (1), el resto solo leer (4), o sea chmod 714 test1. Y los scripts del ex03 y el ex04 están con 644 (rw-r--r--), sin x.

Inodo

La estructura con la que el sistema de ficheros guarda un fichero de verdad: dónde están sus datos, su tamaño, permisos, dueño y fechas. Lo que no guarda es el nombre: los nombres viven en los directorios, como entradas que apuntan a un inodo. ls -i muestra el número de inodo de cada nombre.

Por eso en el ex00 test3 y test5 comparten permisos, tamaño y fecha: son dos nombres del mismo inodo, y el 2 de su columna de enlaces es cuántos nombres tiene.

Enlace duro

Otro nombre para un inodo que ya existe, creado con ln origen nuevo. No hay «original» y «copia»: los dos nombres valen lo mismo, y el fichero solo desaparece cuando se borra el último.

test5 es un enlace duro a test3. tar lo sabe y no guarda los datos dos veces: en tar -tvf exo.tar sale con tipo h y «link to test3».

Enlace simbólico

Un fichero aparte, con su propio inodo, cuyo contenido es una ruta hacia otro. Se crea con ln -s destino nombre. Si el destino se borra o se mueve, el enlace queda roto.

test6 -> test0 es simbólico (tipo l). Su tamaño en el ls -l del enunciado es 5 porque eso ocupa la ruta guardada: los cinco caracteres de test0.

tar

Un empaquetador: junta varios ficheros y directorios en un solo archivo conservando sus nombres, permisos, fechas y enlaces. No comprime por sí mismo. tar -cf x.tar ... crea, -tvf lista y -xf extrae.

El ex00 se entrega como exo.tar, hecho con tar -cf exo.tar *, y es el tar el que conserva los permisos y fechas que comprueba la Moulinette.

Comillas y caracteres especiales de la shell

La shell interpreta muchos caracteres antes de ejecutar nada: $ expande variables, * y ? son comodines, \ escapa el siguiente carácter y las comillas agrupan. Dentro de comillas simples no se interpreta nada; dentro de dobles, todavía se expanden $ y \.

El nombre del ex05, "\?$*'MaRViN'*$?\", está hecho para chocar con todo eso a la vez: la dificultad del ejercicio es escribirlo de forma que la shell no toque ningún carácter.

Compilar y enlazar

Declaración (prototipo) y definición

Una declaración dice cómo se llama una función, qué recibe y qué devuelve, sin cuerpo: void ft_putchar(char a);. Una definición incluye el cuerpo. Con la declaración el compilador ya puede generar la llamada; el cuerpo puede estar en otro fichero.

Los ejercicios que usan ft_putchar solo la declaran, porque la Moulinette compila con su propio ft_putchar.c. Si además la definieran, habría dos definiciones del mismo nombre.

Enlazador

Compilar en C tiene dos fases: el compilador convierte cada .c en un .o (código máquina con huecos donde van las llamadas a otras funciones) y el enlazador junta los .o y las librerías, rellena esos huecos y produce el ejecutable. Si una función no está definida en ninguna parte, o lo está dos veces, falla aquí.

Es lo que une tu ft_is_negative.o con el ft_putchar de la Moulinette, y lo que hace cc $(OBJS) -o $(NAME) en el Makefile del ex27.

Librería estática (.a)

Un archivo que contiene varios .o y un índice de los símbolos que define. Se crea con ar. Al enlazar un programa con ella, el enlazador copia en el ejecutable solo los objetos que necesita.

El ex24 construye libft.a con ar rcs a partir de cinco funciones. Es el mismo mecanismo de la entrega de Libft.

Makefile y relink

make lee reglas de la forma objetivo: dependencias seguidas de los comandos que lo construyen, y solo rehace un objetivo si alguna dependencia es más nueva que él. Relink es volver a enlazar (o a archivar) sin que haya cambiado nada; en 42 es un error.

Con el Makefile del ex24 y cinco fuentes de prueba, el segundo make responde make: Nothing to be done for 'all'.: no hay relink.

Macro del preprocesador

Antes de compilar, el preprocesador sustituye texto: #define crea un nombre que se reemplaza por lo que tenga detrás. Una macro con parámetros hace lo mismo copiando los argumentos tal cual, sin evaluarlos, y no sabe nada de tipos ni de C.

ABS(Value) del ex22 se expande a ((Value) < 0 ? -(Value) : (Value)). Por eso los paréntesis, y por eso ABS(i++) incrementaría i dos veces.

Include guard

El trío #ifndef NOMBRE_H / #define NOMBRE_H / #endif que envuelve una cabecera. La primera vez que se incluye, el nombre no está definido y el contenido entra; las siguientes ya lo está y se salta. Sin esto, incluirla dos veces definiría dos veces lo mismo.

ft_abs.h y ft_point.h lo llevan, con FT_ABS_H y FT_POINT_H.

Datos, punteros y memoria

Puntero y paso por dirección

Un puntero es una variable que guarda la dirección de otra. En C los argumentos se pasan por copia, así que una función solo puede cambiar una variable de quien la llama si recibe su dirección: *p = 42 escribe en la variable a la que apunta p.

ft_ft, ft_swap y ft_div_mod funcionan así; la última devuelve dos resultados escribiéndolos en *div y *mod.

Terminador nulo

En C una cadena es una fila de char que acaba en el byte '\0'. No se guarda la longitud: el final se sabe porque ahí está el cero. Una cadena de n caracteres ocupa n + 1 bytes.

ft_strlen cuenta hasta el cero sin incluirlo, y ft_strcmp se para en él. ft_strdup lo olvida al reservar: pide n bytes y copia n + 1.

char con signo y unsigned char

Un char es un byte, pero el estándar deja a cada sistema decidir si va de −128 a 127 o de 0 a 255. En x86 tiene signo, así que los bytes de 128 a 255 (los de UTF-8 fuera del ASCII) valen negativo.

ft_strcmp resta como unsigned char: con "é" (bytes 0xC3 0xA9) frente a "a" devuelve 98 (195 − 97), positivo, igual que la libc. Restando char con signo saldría negativo.

argc y argv

Los parámetros de main: argc es cuántos argumentos hay y argv un array de punteros a cadenas (char **) con cada uno. argv[0] es el nombre del programa y argv[argc] es NULL.

En ex18 y ex19 el primero se llama argn, y ambos empiezan en i = 1 para saltarse argv[0].

Memoria dinámica: malloc

malloc(n) reserva un bloque de n bytes en el heap, que vive hasta que se libera con free. Si no hay memoria devuelve NULL, y usarlo sin comprobar es un fallo esperando a ocurrir.

ft_strdup y ft_range devuelven memoria nueva que tendrá que liberar quien las llame. Ninguna de las dos comprueba el NULL.

Desbordamiento de heap

Escribir más allá del final de un bloque reservado con malloc. Puede no notarse (malloc suele redondear el tamaño), estropear datos de otro bloque o hacer caer el programa más tarde, lejos del fallo. Valgrind y -fsanitize=address lo detectan.

Con ft_strdup("hola") se reservan 4 bytes y se escriben 5. Valgrind lo señala: un Invalid write of size 1 al copiar y un Invalid read of size 1 al imprimir.

Struct y typedef

Un struct agrupa varias variables bajo un nombre, y typedef le da un alias. Con un puntero, los campos se leen con ->: p->x es (*p).x. La Norma pide s_ para la etiqueta y t_ para el tipo.

ft_point.h define t_point, con x e y; el main del enunciado hace point->x = 42.

Puntero a función

Las funciones también tienen dirección, y se puede guardar en una variable o pasar como argumento. void (*f)(int) se lee «f es un puntero a una función que recibe un int y no devuelve nada». Para llamarla valen (*f)(x) y f(x).

ft_foreach aplica f a cada número sin saber qué hace, y ft_count_if cuenta cuántas cadenas hacen que f devuelva 1.

Algoritmos y aritmética

Recursión

Una función recursiva se llama a sí misma con un problema más pequeño, hasta llegar a un caso base que se resuelve sin volver a llamarse. Cada llamada pendiente ocupa sitio en la pila de llamadas, y con demasiadas se agota.

ft_recursive_factorial(nb) devuelve nb * ft_recursive_factorial(nb - 1) con caso base nb == 0, que da 1. Como corta en 12, nunca pasa de 13 llamadas.

Desbordamiento de entero

Un int de 32 bits va de −2 147 483 648 a 2 147 483 647. Si una operación con signo se sale de ese rango, el resultado es indefinido: en la práctica suele dar la vuelta y salir un número sin sentido.

ft_iterative_factorial(13) devuelve 1932053504 en lugar de 6 227 020 800, mientras que la recursiva devuelve 0. En ft_sqrt, i * i desborda a partir de i = 46341.

Comportamiento indefinido

Lo que el estándar de C no define: el compilador puede hacer cualquier cosa, y lo que haga puede cambiar con las opciones de compilación. Desbordar un entero con signo, dividir entre cero o escribir fuera de un bloque son los ejemplos clásicos.

ft_div_mod con b == 0 es indefinido; en la práctica el programa muere con SIGFPE.

Búsqueda lineal

Probar los candidatos uno a uno, en orden, hasta encontrar el bueno o acabarse. El coste crece en proporción al número de candidatos.

ft_sqrt prueba i = 1, 2, 3... hasta que i * i es nb o hasta llegar a nb. Con nb cerca de 2 147 483 647 y sin raíz exacta son unos dos mil millones de vueltas; parar cuando i * i > nb las dejaría en unas 46 000.

Ordenación por intercambio

Para cada posición, se compara con todas las siguientes y se intercambian cuando están al revés; al acabar con una posición, en ella queda el menor de lo que quedaba. Son dos bucles anidados, así que el coste crece con el cuadrado del número de elementos.

ft_sort_params lo hace sobre argv con ft_strcmp, intercambiando punteros y no letras.

Sistema y reglas de 42

Descriptor de fichero

El número con el que el sistema identifica un fichero abierto. open devuelve uno (o -1 si falla), y read, write y close trabajan con él. Todo proceso nace con tres: 0 la entrada estándar, 1 la salida estándar y 2 la salida de error.

ft_display_file abre el fichero, vuelca su descriptor en el 1 y escribe los mensajes de error en el 2.

Llamada al sistema

Una función que pide el trabajo al núcleo del sistema operativo en lugar de hacerlo ella: open, read, write y close lo son. Cada llamada tiene un coste fijo, así que conviene mover datos en bloques.

Por eso ft_cat_fd lee y escribe de 4096 en 4096 bytes en lugar de byte a byte.

Norma y norminette

La Norma es el estilo obligatorio de 42 (funciones de 25 líneas como mucho, sin for, sin ternarios ni macros con parámetros, cabecera de 42…) y norminette es el programa que la comprueba.

Todos los .c del proyecto la pasan. ft_abs.h no: norminette da MACRO_FUNC_FORBIDDEN, PREPROC_CONSTANT y TERNARY_FBIDDEN, porque el ex22 pide justo eso y el enunciado lo autoriza solo esa vez.

Moulinette

El corrector automático de 42: compila con cc -Wall -Wextra -Werror, pasa la norminette y ejecuta sus propias pruebas. No hay discusión posible.

La Piscine Reloaded la corrige solo la Moulinette, en orden: un ejercicio no cuenta si falla uno anterior.

ex00Dame más... — exo.tar

Entrega: exo.tarAutorizado: ninguna

Reproducir un ls -l exacto de siete entradas (permisos, tamaños, fechas y un enlace simbólico) y empaquetarlo con tar -cf exo.tar *. Es el testShell00 de la piscine, pero con siete ficheros en vez de uno. Lo que hay de verdad dentro del tar entregado:

$ tar -tvf exo.tar
drwx--xr-x xavilara/xavilara 0 2026-06-01 20:47 test0/
-rwx--xr-- xavilara/xavilara 4 2026-06-01 21:46 test1
dr-x---r-- xavilara/xavilara 0 2026-06-01 22:45 test2/
-r-----r-- xavilara/xavilara 1 2026-06-01 23:44 test3
-rw-r----x xavilara/xavilara 2 2026-06-01 23:43 test4
hr-----r-- xavilara/xavilara 0 2026-06-01 23:44 test5 link to test3
lrwxrwxrwx xavilara/xavilara 0 2026-06-01 22:20 test6 -> test0

La parte nueva respecto a la piscine está en test3 y test5. En el ls -l del enunciado los dos tienen un 2 en la columna de enlaces, los mismos permisos, el mismo tamaño y la misma fecha: no son dos ficheros, son dos nombres para el mismo fichero, un enlace duro (ln test3 test5). El tar lo sabe y no guarda dos copias: test5 aparece con tipo h y "link to test3". En cambio test6 es un enlace simbólico (l): un fichero aparte cuyo contenido es la ruta test0 (5 bytes, de ahí su tamaño en el ls -l).

Qué te obliga a aprender — La diferencia entre nombre y fichero. En Unix el fichero de verdad es el inodo (datos + permisos + fechas); los nombres de los directorios son solo entradas que apuntan a un inodo, y el contador de enlaces dice cuántas hay. Un enlace duro es otra entrada al mismo inodo (por eso comparte permisos y fecha: son literalmente los mismos); uno simbólico es un inodo distinto que contiene una ruta y que se rompe si la ruta desaparece. El 2 de los directorios test0 y test2 sale de lo mismo: su propio nombre más la entrada . que llevan dentro.

ex01–ex05z, clean, find_sh, MAC y MaRViN

Entrega: z, clean, find_sh.sh, MAC.sh, "\?$*'MaRViN'*$?\"Autorizado: ninguna

Los cinco son ejercicios de Shell 00 y Shell 01 repetidos casi palabra por palabra, así que basta con el código y el enlace a su explicación completa:

# ex01/z  — Shell 00 · Z
Z

# ex02/clean  — Shell 00 · clean
find . -type f \( -name "*~" -o -name "#*#" \) -print -delete

# ex03/find_sh.sh  — Shell 01 · find_sh
find . -type f -name '*.sh' | sed 's|.*/||; s|\.sh$||'

# ex04/MAC.sh  — Shell 01 · MAC
ifconfig | awk '/ether/ {print $2}'

Ojo: en el repositorio los tres scripts están con permisos 644 (git los guarda como 100644), sin bit de ejecución. El ejemplo del enunciado los lanza como ./find_sh.sh, que así daría "Permission denied"; con sh find_sh.sh funcionan igual.

Qué te obliga a aprender — Que la shell no se olvida tras la piscine: find con sus expresiones, tuberías hacia filtros como sed y awk, y el quoting. Son las herramientas con las que más adelante se buscan ficheros, se limpian proyectos o se automatizan pruebas, y el cursus da por hecho que las manejas.

ex06–ex08ft_print_alphabet, ft_print_numbers, ft_is_negative

Entrega: ft_print_alphabet.c, ft_print_numbers.c, ft_is_negative.cAutorizado: ft_putchar

Los mismos que en C 00 · ex01, ex03 y ex04, con un cambio: ya no se usa write directamente sino ft_putchar, que solo se declara.

void	ft_putchar(char a);

void	ft_is_negative(int n)
{
	char	a;

	if (n < 0)
		a = 'N';
	else
		a = 'P';
	ft_putchar(a);
}

Alfabeto y números son el mismo bucle while (a <= 'z') / while (a <= '9') sobre un char. En ft_is_negative el if solo elige la letra y hay una única llamada de salida al final.

Qué te obliga a aprender — La separación entre declaración y definición. El prototipo le dice al compilador cómo se llama la función y qué recibe, suficiente para generar la llamada; el cuerpo lo pondrá el enlazador al juntar tu .o con el ft_putchar.c de la Moulinette. Es la misma mecánica con la que, en unos días, tus programas usarán las funciones de libft.a a través de libft.h.

ex09–ex11ft_ft, ft_swap, ft_div_mod

Entrega: ft_ft.c, ft_swap.c, ft_div_mod.cAutorizado: ninguna

Punteros como parámetros de salida, exactamente como en C 01 · ft_ft, ft_swap y ft_div_mod:

*nbr = 42;                 /* ft_ft */

t = *a;                    /* ft_swap */
*a = *b;
*b = t;

*div = a / b;              /* ft_div_mod */
*mod = a % b;

Ojo: ft_div_mod no comprueba b == 0; dividir entre cero es comportamiento indefinido (en la práctica, el programa muere con SIGFPE). El enunciado no dice qué hacer en ese caso, así que es una decisión aceptable, pero conviene saberlo.

Qué te obliga a aprender — Que en C todo se pasa por copia y que la única forma de que una función cambie una variable del llamante es recibir su dirección. Es también la manera de "devolver dos valores" (cociente y resto) cuando return solo permite uno.

ex12–ex14ft_iterative_factorial, ft_recursive_factorial, ft_sqrt

Entrega: ft_iterative_factorial.c, ft_recursive_factorial.c, ft_sqrt.cAutorizado: ninguna

Los ejercicios de C 05 (factorial iterativo, recursivo y sqrt). Las dos versiones del factorial:

/* ex12: iterativo */
if (nb < 0)
	return (0);
i = 1;
j = 1;
while (nb >= j)
{
	i = i * j;
	j++;
}
return (i);

/* ex13: recursivo */
if (nb < 0)
	return (0);
else if (nb == 0)
	return (1);
else if (nb > 12)
	return (0);
else
	return (nb * ft_recursive_factorial(nb - 1));

La recursiva tiene un detalle interesante: nb > 12 devuelve 0, porque 13! ya no cabe en un int de 32 bits (12! = 479 001 600, 13! ≈ 6 200 millones). Ojo: la iterativa no tiene ese límite, así que con nb >= 13 el producto desborda (comportamiento indefinido en enteros con signo) y devuelve un valor sin sentido. Las dos funciones del mismo proyecto se comportan distinto para la misma entrada.

int	ft_sqrt(int nb)
{
	int	i;

	i = 1;
	while (i * i != nb && i < nb)
		i++;
	if (nb == 1)
		return (1);
	if (i >= nb)
		return (0);
	else
		return (i);
}

Búsqueda lineal: sube i hasta que su cuadrado coincide o hasta llegar a nb. El caso nb == 1 se trata aparte porque ahí i termina valiendo nb y la comprobación siguiente lo confundiría con "no hay raíz". Ojo: para números grandes que no son cuadrados perfectos, el bucle sigue hasta i = nb; a partir de i = 46341 el producto i * i se sale del int (desbordamiento, comportamiento indefinido) y para nb cercanos a 2 147 483 647 son unos dos mil millones de vueltas, al límite de los dos segundos que pide el enunciado.

Qué te obliga a aprender — Recursión frente a iteración sobre el mismo problema, y sobre todo que los enteros de la máquina tienen techo. El factorial crece tan deprisa que el rango útil de un int acaba en 12; la raíz deja de poder calcularse con i * i en 46 340. Saber dónde está ese techo es parte del ejercicio.

ex15–ex17ft_putstr, ft_strlen, ft_strcmp

Entrega: ft_putstr.c, ft_strlen.c, ft_strcmp.cAutorizado: ft_putchar (solo ex15)

Las tres funciones de cadenas básicas, vistas en C 01 · ft_putstr, C 01 · ft_strlen y C 03 · ft_strcmp. ft_putstr y ft_strlen son el mismo recorrido while (str[i]): una imprime cada carácter, la otra solo cuenta. La que tiene miga es strcmp:

int	ft_strcmp(char *s1, char *s2)
{
	int	i;

	i = 0;
	while (s1[i] && s2[i] && s1[i] == s2[i])
		i++;
	return ((unsigned char) s1[i] - (unsigned char) s2[i]);
}

Avanza mientras las dos cadenas sigan y coincidan, y devuelve la diferencia del primer carácter distinto (o del '\0' de la más corta). La conversión a unsigned char es lo que hace la libc real: así un carácter como 'é' en UTF-8 (bytes ≥ 128) se ordena después de los ASCII y no antes, como pasaría restando char con signo, que es lo habitual en x86.

Qué te obliga a aprender — Que una cadena en C no es un tipo sino un convenio: bytes seguidos que terminan en '\0'. Las tres funciones se reducen a recorrer hasta ese cero. Son además tres de las cinco que compilará el Makefile del ex24.

ex18–ex19ft_print_params y ft_sort_params

Entrega: ft_print_params.c, ft_sort_params.cAutorizado: ft_putchar

Los dos primeros programas (con main) del proyecto, como en C 06 · ft_print_params y C 06 · ft_sort_params. El código llama argn a lo que suele llamarse argc; el nombre da igual, lo que cuenta es la posición del parámetro. La ordenación de ex19:

i = 1;
while (i < (argn))
{
	j = i + 1;
	while (j < argn)
	{
		if (ft_strcmp(argv[i], argv[j]) > 0)
		{
			temp = argv[i];
			argv[i] = argv[j];
			argv[j] = temp;
		}
		j++;
	}
	i++;
}
ft_putarraystr(argn, argv);

Es una ordenación por intercambio: para cada posición i, compara con todas las siguientes y se queda con la menor. Empieza en 1 para no tocar argv[0] (el nombre del programa). Lo que se intercambia son los punteros de argv, no las letras: mover una dirección cuesta lo mismo sea la cadena larga o corta. ft_strcmp se copia dentro del fichero porque en este ejercicio solo se entrega un .c.

Qué te obliga a aprender — Que argv es un array de punteros a cadenas (char **) y que puedes reordenarlo como cualquier array. Es el primer contacto con ordenar datos "por referencia", algo que en push_swap o en cualquier estructura de datos grande se hace siempre así.

ex20–ex21ft_strdup y ft_range

Entrega: ft_strdup.c, ft_range.cAutorizado: malloc

Memoria dinámica, como en C 07 · ft_strdup y C 07 · ft_range.

char	*ft_strdup(char *src)
{
	char	*dest;
	int		n;

	n = ft_strlen(src);
	dest = (char *) malloc(sizeof(char) * n);
	return (ft_strcopy(dest, src));
}

Ojo, aquí hay un fallo de verdad: ft_strlen cuenta los caracteres sin el '\0', pero ft_strcopy copia también el terminador (dest[i] = src[i] tras el bucle). Se reservan n bytes y se escriben n + 1: un byte fuera del bloque (desbordamiento de heap). Muchas veces no se nota porque malloc redondea el tamaño hacia arriba, pero valgrind o -fsanitize=address lo señalan, y una Moulinette que lo compruebe lo cuenta como error. Tampoco se comprueba si malloc devuelve NULL antes de copiar.

if (max - min < 1)
	return (NULL);
r = (int *) malloc(sizeof(int) * (max - min));
i = 0;
while (i < max - min)
{
	r[i] = min + i;
	i++;
}
return (r);

ft_range calcula el tamaño como max - min y rellena con min + i, lo que da el intervalo [min, max) que pide el enunciado. Igual que strdup, no comprueba el NULL de malloc; y con extremos muy separados (por ejemplo INT_MIN e INT_MAX) la resta max - min desborda el int.

Qué te obliga a aprender — A contar bytes. Toda reserva de memoria es un contrato de tamaño, y en las cadenas siempre hay un byte más que los caracteres visibles: el '\0'. El "más uno" que falta aquí es probablemente el error más repetido de todo C, y el de Libft (ft_strdup, ft_substr, ft_strjoin...) depende de tenerlo interiorizado.

ex22–ex23ft_abs.h y ft_point.h

Entrega: ft_abs.h, ft_point.hAutorizado: ninguna

Dos cabeceras, como en C 08 · ft_abs.h y C 08 · ft_point.h. Ninguna contiene código que se ejecute: una define una macro y la otra un tipo.

#ifndef FT_ABS_H
# define FT_ABS_H

# define ABS(Value) ((Value) < 0 ? -(Value) : (Value))

#endif

La macro usa el operador ternario y una macro con parámetros, dos cosas que la Norma prohíbe; el propio enunciado avisa de que es "la única vez que lo autoricemos". Los paréntesis alrededor de cada (Value) no son decoración: sin ellos, ABS(a - b) se expandiría a -a - b en vez de -(a - b). Lo que no pueden evitar es que Value aparezca dos veces: ABS(i++) incrementaría i dos veces. Y ABS(INT_MIN) desborda, igual que en el putnbr de la piscine.

#ifndef FT_POINT_H
# define FT_POINT_H

typedef struct s_point
{
	int	x;
	int	y;
}	t_point;

#endif

Basta con esto para que compile el main del enunciado (point->x = 42; point->y = 21;). El struct s_point agrupa dos enteros bajo un nombre, y el typedef le pone el alias t_point para no tener que escribir struct s_point cada vez. Los prefijos s_ y t_ son convención de la Norma: s_ para la etiqueta del struct, t_ para el tipo.

Qué te obliga a aprender — Dos cosas del preprocesador y del sistema de tipos. La macro enseña que #define es sustitución de texto antes de compilar, sin saber nada de C: por eso hay que proteger los argumentos con paréntesis y por eso se evalúan tantas veces como aparecen. El struct es la otra mitad: crear tipos propios que agrupan datos. Con -> se accede a un campo a través de un puntero (p->x es (*p).x). Y los include guards (#ifndef ... #endif) evitan que, si la cabecera se incluye dos veces, el tipo se defina dos veces y falle la compilación. Es exactamente el esqueleto que tendrá libft.h con su t_list.

ex24Makefile

Entrega: MakefileReglas: all, clean, fclean, re

Un Makefile que compile libft.a con cinco funciones de los ejercicios anteriores (ft_putchar, ft_putstr, ft_strcmp, ft_strlen, ft_swap), con las fuentes en srcs/, las cabeceras en includes/ y la librería en la raíz. Solo se entrega el Makefile; la Moulinette pone sus propios ficheros. Es el mismo ejercicio que C 09 · Makefile, y en el cursus se vuelve central porque es la base de la entrega de Libft:

NAME = libft.a
SRCS = srcs/ft_putchar.c \
	   srcs/ft_putstr.c \
	   srcs/ft_strcmp.c \
	   srcs/ft_strlen.c \
	   srcs/ft_swap.c
OBJS = $(SRCS:.c=.o)
CFLAGS = -Wall -Wextra -Werror -Iincludes

all: $(NAME)

$(NAME): $(OBJS)
	ar rcs $(NAME) $(OBJS)

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

clean:
	rm -f $(OBJS)

fclean: clean
	rm -f $(NAME)

re: fclean all

.PHONY: all clean fclean re

Pieza a pieza:

Una limitación (que el enunciado no pide resolver): los .o dependen solo de su .c, no de las cabeceras de includes/. Si cambia un .h, make no recompila nada hasta un make re.

Qué te obliga a aprender — Qué es una librería estática y cómo se construye. libft.a no es más que un archivo (ar = archiver, el antepasado de tar) con varios .o dentro y un índice. Al enlazar un programa con cc main.c libft.a, el enlazador saca de ahí solo los objetos que necesita y los copia en el ejecutable. Y make decide qué rehacer comparando fechas: si un .c es más nuevo que su .o, lo recompila; si no, lo deja. Todo el cursus en C (Libft, ft_printf, get_next_line, push_swap) se entrega con un Makefile con estas mismas reglas, y la evaluación comprueba que no recompile de más.

ex25–ex26ft_foreach y ft_count_if

Entrega: ft_foreach.c, ft_count_if.cAutorizado: ninguna

Punteros a función, como en C 11 · ft_foreach y C 11 · ft_count_if:

void	ft_foreach(int *tab, int length, void (*f)(int))
{
	int	i;

	i = 0;
	while (i < length)
	{
		(*f)(tab[i]);
		i++;
	}
}

int	ft_count_if(char **tab, int (*f)(char *))
{
	...
	while (tab[i] != 0)
	{
		if ((*f)(tab[i]) == 1)
			j++;
		i++;
	}
	return (j);
}

void (*f)(int) se lee "f es un puntero a una función que recibe un int y no devuelve nada". (*f)(x) y f(x) son equivalentes en C; aquí se usa la forma explícita. ft_count_if recorre hasta el puntero nulo que marca el final del array (lo que el enunciado llama "delimitado por 0") y cuenta las veces que f devuelve exactamente 1, que es lo que pide la letra del enunciado. En ft_foreach.c sobra el #include <stdio.h>, aunque no hace daño.

Qué te obliga a aprender — Que las funciones también tienen dirección y se pueden pasar como datos. ft_foreach no sabe qué hará con cada número: lo decide quien la llama. Es la idea que reaparece en ft_lstiter y ft_lstmap de Libft, en qsort de la libc o en los callbacks de cualquier biblioteca.

ex27display_file

Entrega: Makefile, ft_display_file.cAutorizado: open, read, write, close

Un programa ft_display_file que muestra el contenido del fichero que recibe como argumento, sin malloc (solo un array de tamaño fijo) y con tres mensajes de error concretos por la salida de error. Es el display_file de C 10, el último ejercicio del proyecto y el único que lee de disco.

void	ft_cat_fd(int fd)
{
	char	buf[4096];
	int		n;

	n = read(fd, buf, sizeof(buf));
	while (n > 0)
	{
		write(1, buf, n);
		n = read(fd, buf, sizeof(buf));
	}
}

int	main(int argc, char **argv)
{
	int	fd;

	if (argc < 2)
	{
		ft_putstr_fd("File name missing.", 2);
		return (0);
	}
	if (argc > 2)
	{
		ft_putstr_fd("Too many arguments.", 2);
		return (0);
	}
	fd = open(argv[1], O_RDONLY);
	if (fd < 0)
	{
		ft_putstr_fd("Cannot read file.", 2);
		return (1);
	}
	ft_cat_fd(fd);
	close(fd);
	return (0);
}

El orden es: validar el número de argumentos, abrir, volcar y cerrar. El volcado es el bucle clásico de lectura: read llena como mucho 4096 bytes y devuelve cuántos leyó; write(1, buf, n) escribe esos n, no 4096, porque el último trozo casi nunca llena el buffer. Cuando read devuelve 0 es el fin del fichero, y -1 un error; los dos cortan el bucle. Así se muestra un fichero de cualquier tamaño con solo 4 KB de memoria. Los mensajes salen por el descriptor 2 y el salto de línea lo añade el propio ft_putstr_fd de este fichero (no es el de Libft: escribe la cadena y luego un "\n").

Ojo con dos detalles. Si open funciona pero read falla (por ejemplo, al pasarle un directorio: open con O_RDONLY lo abre, pero read devuelve -1), el bucle simplemente no entra y el programa termina sin escribir nada y sin el "Cannot read file.". El enunciado dice que los ficheros serán válidos, así que no debería pasar en la corrección. Y los códigos de salida no son uniformes: los errores de argumentos devuelven 0 y el de lectura 1; el enunciado no exige ninguno en concreto.

NAME = ft_display_file
SRCS = ft_display_file.c
OBJS = $(SRCS:.c=.o)
CFLAGS = -Wall -Wextra -Werror

all: $(NAME)

$(NAME): $(OBJS)
	cc $(CFLAGS) $(OBJS) -o $(NAME)
...
.PHONY: all clean fclean

El Makefile es el del ex24 con un cambio en la regla final: en vez de archivar con ar, enlaza los objetos en un ejecutable con cc ... -o. Aquí no hay regla re porque el enunciado solo pide all, clean y fclean.

Qué te obliga a aprender — A hablar con el sistema operativo sin intermediarios. open, read, write y close son llamadas al sistema: un fichero abierto es solo un número (el descriptor) y leer es pedirle al kernel "dame hasta N bytes". El bucle read + write con un buffer fijo es, literalmente, el corazón de cat. Y es la antesala directa de get_next_line, donde ese mismo read por trozos tendrá que cortarse en líneas y recordar lo que sobró entre llamada y llamada. Separar la salida normal (fd 1) de los errores (fd 2) es lo que permite ./ft_display_file f > copia sin que los mensajes de error acaben dentro de la copia.

?Preguntas probables de la evaluación

La Piscine Reloaded la corrige solo la Moulinette, pero son preguntas que salen en cuanto alguien revisa este código, y en las defensas de Libft y de los proyectos siguientes. Cada una tiene una respuesta corta y el enlace a la sección donde está explicado a fondo. Están agrupadas en: shell, C, Makefile y entrega, y puntos débiles. Antes de mirar la respuesta, intenta contestar tú.

Shell

¿Qué diferencia hay entre test5 y test6 en el ex00?

test5 es un enlace duro a test3: otro nombre del mismo inodo, con sus mismos permisos, tamaño y fecha, y un 2 en la columna de enlaces. test6 es un enlace simbólico a test0: un fichero aparte que guarda la ruta, de ahí sus 5 bytes. Si se borra test0, test6 queda roto. → ex00

¿Por qué ./find_sh.sh da «Permission denied»?

Porque en el repositorio los scripts tienen permisos 644, sin el bit de ejecución. Se arregla con chmod +x find_sh.sh, o se lanza con sh find_sh.sh, que solo necesita leerlo. → ex01–ex05

C

¿Dónde está definido ft_putchar? ¿Por qué solo lo declaras?

Lo pone la Moulinette, que compila con su propio ft_putchar.c. El fichero solo lleva el prototipo, suficiente para que el compilador genere la llamada; el enlazador junta después los dos objetos. Si también lo definiera, habría dos definiciones y el enlace fallaría. → ex06–ex08

¿Qué devuelven tus factoriales con 13?

La recursiva, 0, porque corta en nb > 12: 13! no cabe en un int. La iterativa no corta y el producto desborda: devuelve 1932053504. Las dos funciones se comportan distinto con la misma entrada. → ex12–ex14

¿Por qué conviertes a unsigned char en ft_strcmp?

Para comparar como la libc. En x86 el char tiene signo y los bytes de 128 en adelante valdrían negativo; así "é" frente a "a" da 98, positivo, y la é se ordena después de los ASCII. → ex15–ex17

En ft_sort_params, ¿qué intercambias exactamente?

Los punteros de argv, no las letras: cuesta lo mismo sea la cadena larga o corta. Es una ordenación por intercambio que empieza en i = 1 para no mover el nombre del programa. → ex18–ex19

¿Por qué ft_abs.h no pasa la norminette? ¿Para qué tantos paréntesis?

Porque el ejercicio pide justo una macro con parámetros y un ternario, que la Norma prohíbe; el enunciado lo autoriza solo esa vez. Los paréntesis evitan que ABS(a - b) se expanda a -a - b. Lo que no evitan es que ABS(i++) incremente dos veces. → ex22–ex23

¿Qué es void (*f)(int)?

Un parámetro que es un puntero a una función que recibe un int y no devuelve nada. ft_foreach lo llama con cada elemento sin saber qué hace; lo decide quien llama. Es la idea de ft_lstiter y ft_lstmap en Libft. → ex25–ex26

Makefile y entrega

¿Qué hace ft_display_file sin argumentos, con dos o con un fichero que no existe?

Escribe por la salida de error File name missing., Too many arguments. o Cannot read file., cada uno con su salto de línea. Los dos primeros salen con código 0 y el tercero con 1. → ex27

Puntos débiles (mejor tener la respuesta preparada)

¿Ves algún fallo en ft_strdup?

Sí: reserva ft_strlen(src) bytes y copia también el '\0', así que escribe uno de más. Valgrind lo marca como Invalid write of size 1. Falta el + 1 en el malloc, y comprobar si devuelve NULL. → ex20–ex21

¿Qué pasa con ft_div_mod si b es 0? ¿Y ft_sqrt con números enormes?

ft_div_mod divide entre cero: comportamiento indefinido, y en la práctica el programa muere con SIGFPE. ft_sqrt sigue subiendo i hasta nb aunque i * i ya se haya pasado, así que desborda y da miles de millones de vueltas; parar cuando i * i > nb lo arreglaría. → ex09–ex11, ex12–ex14

¿Y si a ft_display_file le pasas un directorio?

open lo abre, pero read devuelve -1: el bucle no entra y el programa acaba sin escribir nada, con código 0 y sin Cannot read file.. El enunciado garantiza ficheros válidos, así que no debería salir en la corrección. → ex27