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.
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.)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.
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.
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.
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».
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.
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.
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.
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.
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.
.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.
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.
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.
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.
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.
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 charUn 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 argvLos 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].
mallocmalloc(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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
test0 y test2 sale de lo mismo: su
propio nombre más la entrada . que llevan dentro.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}'
Z y el salto de línea; cat no añade
nada, así que el salto tiene que estar en el fichero.-o (OR) para que
-type f se aplique a los dos patrones, y -print -delete muestra y borra
en el mismo comando, que es justo lo que pide la regla de "nada de ; ni
&&".s de sed quita todo hasta la última
/ (la ruta) y el segundo quita el .sh final.ifconfig de Linux la MAC va en la línea
ether xx:xx:...; awk filtra esas líneas e imprime el segundo campo.42 sin salto de línea (2 bytes). La
dificultad era solo crear un nombre lleno de caracteres especiales de la shell.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.
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.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.
.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.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.
return solo permite uno.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.
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.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.
'\0'. Las tres funciones se reducen a recorrer
hasta ese cero. Son además tres de las cinco que compilará el Makefile del ex24.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.
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í.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.
'\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.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.
#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.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:
SRCS lista las fuentes a mano, una por línea con
\. El enunciado avisa "¡Cuidado con los wildcards!": nada de
$(wildcard srcs/*.c), porque compilaría cualquier fichero que apareciera en la carpeta
(y la Norma de 42 lo prohíbe en los Makefile).OBJS = $(SRCS:.c=.o): sustitución de sufijo. Convierte la lista
de .c en la lista de .o sin escribirla dos veces. Los objetos quedan junto
a sus fuentes, en srcs/.-Iincludes: añade includes/ a las carpetas donde el
compilador busca los #include "...". Va dentro de CFLAGS, así que se usa
en cada compilación.all: $(NAME): la primera regla es la que se ejecuta con un
make a secas; aquí solo dice "lo que quiero es libft.a".$(NAME): $(OBJS): la librería depende de los objetos, y se
construye con ar rcs: r inserta (o reemplaza) los .o en el
archivo, c lo crea sin avisar si no existe, s escribe el índice de símbolos
que el enlazador usa para encontrar cada función.%.o: %.c: regla patrón. Cualquier X.o se hace a
partir de su X.c. $< es el primer prerequisito (el .c) y
$@ el objetivo (el .o).clean borra objetos; fclean
depende de clean y además borra la librería; re encadena
fclean y all..PHONY: declara que esas reglas no son ficheros. Sin ella, si
alguien crea un fichero llamado clean, make clean diría que ya está hecho
y no borraría nada.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.
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.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.
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.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.
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.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ú.
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
./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
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
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
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
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
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
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
ar rcs?No: un segundo make responde Nothing to be done for 'all', porque
libft.a es más nueva que sus objetos. ar rcs mete o reemplaza los
.o en el archivo (r), lo crea si no existe (c) y escribe el
índice de símbolos (s). Ojo: si cambia una cabecera no recompila nada.
→ ex24
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
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
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
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