El módulo de la compilación. Aquí se deja de compilar a mano: se
crea una librería estática (libft.a) y se automatiza su construcción con un
Makefile. Se aprende qué hace el enlazador y por qué existe make.
3 ejercicios (ex00–ex02).
make) para que sepa qué construir y cómo.C 09 es el primer módulo en el que lo importante no es lo que hace el código, sino cómo se
construye. Las palabras vienen de la cadena de compilación de C y de make. Aquí está
cada una explicada desde cero y con un ejemplo sacado del propio módulo. 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. Las
salidas que aparecen se han obtenido ejecutando el script y el Makefile de esta página
con cinco fuentes de prueba.
.c a .o)cc hace en realidad varios pasos seguidos: el preprocesador resuelve los
#include y #define, el compilador traduce el C a código máquina y, al
final, el enlazador lo junta todo en un ejecutable. Con -c se para antes de enlazar y
deja un archivo objeto por cada .c.
Cada .c se compila solo, sin ver los demás: ft_putstr.c puede llamar a
ft_putchar porque incluye el prototipo, aunque el código esté en otro archivo.
.o)El resultado de compilar un .c con -c: código máquina de sus funciones,
más una lista de lo que define y de lo que usa sin definir. No se puede ejecutar porque le falta lo
que viene de fuera (y, aquí, no tiene main).
Si se intenta crear un ejecutable a partir de ft_putchar.c sin -c,
compila bien pero falla al enlazar:
(.text+0x1b): undefined reference to `main'
collect2: error: ld returned 1 exit status
undefined referenceUn símbolo es el nombre de una función o variable global tal como lo ve el enlazador.
Cada .o lleva los símbolos que define (ft_strlen en
ft_strlen.o) y los que necesita de otros (si tu ft_putstr llama a
ft_putchar, ese es un símbolo que ft_putstr.o necesita y no define).
nm archivo.o los lista: T delante de los definidos, U delante
de los que faltan.
Si al enlazar nadie define uno que se necesita, el enlazador da undefined
reference. Un main que llama a ft_putstr, compilado sin la
librería:
m.c:(.text+0x13): undefined reference to `ft_putstr'
ld)El último paso: el enlazador junta los .o, empareja cada símbolo usado con el que lo
define y escribe el ejecutable. En Linux es ld, y cc lo llama por ti
(collect2 es el intermediario que sale en los errores).
Para usar libft.a: cc main.c -L. -lft. -L. dice dónde
buscar y -lft busca libft.a (el prefijo lib y la extensión se
ponen solos). El orden importa: el enlazador recorre los archivos de izquierda a derecha y de una
librería solo saca lo que alguien ha pedido antes. Con
cc -L. -lft main.c falla con el mismo undefined reference to `ft_putstr'.
.a) y ar rcsUn archivo que guarda varios .o juntos, con un índice de los símbolos que define.
Se crea con ar, el «archivador»: r mete los .o (reemplazando
los que ya estuvieran), c crea el .a sin avisar si no existía y
s escribe el índice. ar t libft.a lista lo que hay dentro:
ft_putchar.o
ft_swap.o
ft_putstr.o
ft_strlen.o
ft_strcmp.o
«Estática» quiere decir que al enlazar se copian dentro del ejecutable los .o que se
usan; después el programa ya no necesita el .a. La alternativa es una librería
dinámica (.so): el ejecutable solo apunta a ella y el sistema la carga al
arrancarlo, así que varios programas comparten la misma copia, como pasa con la libc.
-Wall -Wextra -Werror-Wall y -Wextra encienden avisos (warnings) sobre código
legal pero sospechoso: una variable sin usar, una comparación entre con signo y sin signo, una
función que no devuelve nada en algún camino. -Werror convierte cada aviso en error, de
modo que no se genera nada.
La Moulinette compila siempre con los tres, y el enunciado de ex01 pide ponerlos «en ese orden». Un aviso que en casa ignoras es, en la corrección, un ejercicio que no compila y un 0.
Un archivo de texto con comandos de la shell, uno detrás de otro, que se ejecutan como si los
escribieras tú. sh libft_creator.sh lanza un sh que lo lee y ejecuta sus
líneas. La primera, #!/bin/sh (el shebang), solo se usa si lo ejecutas
directamente como ./libft_creator.sh, y entonces necesita permiso de ejecución.
Un script no sabe nada de qué ha cambiado: repite todos los comandos cada vez. Esa es la
diferencia con make.
Un Makefile es una lista de reglas. Cada una dice qué se quiere obtener
(el objetivo), de qué depende (los prerequisitos) y cómo se hace (la
receta, en las líneas siguientes y empezando obligatoriamente por un tabulador):
$(NAME): $(OBJS) ← objetivo: prerequisitos
ar rcs $(NAME) $(OBJS) ← receta (tabulador delante)
make sin nada construye el primer objetivo del archivo; por eso all va
el primero y make equivale a make all, como pide el enunciado. Y
make imprime cada comando antes de ejecutarlo, que es lo de «tu makefile debe mostrar
cada comando».
Las reglas forman un grafo: all necesita libft.a, que necesita cinco
.o, cada uno de los cuales necesita su .c. make lo recorre y
solo rehace un objetivo si no existe o si algún prerequisito es más nuevo que él (compara las fechas
de modificación de los archivos).
Con el Makefile de ex01, un segundo make responde
make: Nothing to be done for 'all'., y tras un touch srcs/ft_swap.c solo
recompila ese archivo y vuelve a hacer el ar. La otra cara: make solo
sabe lo que pones en las reglas. includes/ft.h no figura como prerequisito, así que si
lo cambias tampoco hace nada.
%.o: %.c, $<, $@)Una regla con % vale para muchos archivos a la vez: %.o: %.c dice «para
hacer cualquier X.o, a partir de X.c». Dentro de la receta,
$@ es el objetivo de ese momento y $< su primer prerequisito.
Para srcs/ft_swap.o, la receta se convierte en
cc -Wall -Wextra -Werror -I includes -c srcs/ft_swap.c -o srcs/ft_swap.o. Como el
.o se escribe con la misma ruta que el .c, queda a su lado, que es lo que
pide el enunciado.
$(SRCS:.c=.o)NAME = libft.a define una variable y $(NAME) la usa. Sirven para no
repetir listas ni opciones: cambiar los flags es tocar una línea. $(SRCS:.c=.o) es la
misma lista que SRCS con cada .c final cambiado por .o:
srcs/ft_putchar.o srcs/ft_swap.o ….
CC y CFLAGS son nombres que make ya conoce, pero en
ex01 se usan de forma explícita en la regla de patrón, así que el comando que se ve es exactamente
el escrito.
.PHONYDeclara objetivos que no son archivos, sino nombres de acciones: all,
clean, fclean, re. Sin eso, make los trata como
archivos y, si por casualidad existe uno con ese nombre, cree que ya está hecho. Probado con un
archivo vacío llamado clean y el .PHONY quitado:
make: 'clean' is up to date.
y no borra nada. Con .PHONY la receta se ejecuta siempre.
Un patrón como *.c que se expande a todos los archivos que encajan. En un
Makefile se escribiría $(wildcard srcs/*.c). Es cómodo, pero compila lo
que haya en la carpeta, no lo que debe haber: un main.c de pruebas olvidado acaba
dentro de la librería, y uno que falta no da ningún error.
Por eso el enunciado avisa «¡Ten cuidado con los wildcards!»: solo se recoge tu
Makefile y se prueba con los archivos de la Moulinette, así que tiene que nombrar
exactamente los cinco fuentes que pide.
char **: puntero a puntero y array de cadenasUna cadena en C es un char *, la dirección de su primer carácter. Un array de
cadenas es entonces un array de char *, y la dirección de su primer elemento es un
char **. argv es el ejemplo de siempre.
ft_split devuelve uno: tab[0] es la primera palabra (un
char *) y tab[0][0] su primera letra (un char). Hacen falta
dos niveles de reserva: uno para el array de punteros y uno por cada palabra.
mallocmalloc(n) reserva n bytes en el heap y devuelve su dirección, o
NULL si no hay memoria. Esa memoria sigue viva al salir de la función y hasta que
alguien llama a free. Es la única forma de devolver un resultado cuyo tamaño no se
conoce antes de ejecutar.
En ft_split, para "hola mundo" con " " hay tres reservas:
3 punteros (dos palabras y el NULL), 5 bytes para "hola" y 6 para
"mundo", siempre con uno más para el '\0'. Solo malloc está
autorizado, no free: liberar es cosa de quien recibe el resultado.
NULLUn valor especial que marca el final de una secuencia, para no tener que devolver su longitud
aparte. El enunciado pide que el último elemento del array de ft_split sea 0: quien lo
recibe avanza con while (tab[i]) hasta encontrarlo. Es el mismo truco que el
'\0' de las cadenas o el NULL tras el último argv.
Cuando hay que reservar memoria para un resultado que todavía no conoces, se recorre la entrada
dos veces: la primera solo cuenta y la segunda rellena la memoria ya reservada con el tamaño exacto.
Cuesta una pasada más, pero evita reservar de más o tener que agrandar el array por el camino (y
realloc no está autorizado).
En ft_split: contar palabras para reservar palabras + 1 punteros, y para
cada palabra medir su longitud antes de reservar longitud + 1 bytes.
Para ft_split, un separador es cualquier carácter que aparezca en
charset, y una palabra es un tramo de uno o más caracteres que no lo son. Una
cadena vacía es "": un solo '\0', longitud 0.
Si se cortara a ciegas en cada separador, ",,a," con "," daría
"", "", "a" y "". El enunciado prohíbe las cadenas
vacías, así que la única palabra es "a": los separadores del principio, del final y los
repetidos no producen nada. Una palabra empieza donde un carácter no separador va detrás de un
separador o del inicio.
Memoria reservada con malloc que nadie libera y cuya dirección se ha perdido. En
ft_split hay un caso clásico: si el malloc de la tercera palabra falla, las
dos primeras y el array ya están reservados. Devolver NULL sin más los pierde; lo
correcto es liberarlos antes. Como free no está autorizado en este ejercicio, la mayoría
de soluciones de la piscine se limitan a devolver NULL, y conviene saber explicarlo.
Crear la biblioteca libft.a con cinco funciones (ft_putchar,
ft_swap, ft_putstr, ft_strlen, ft_strcmp) y un
script que la construya:
#!/bin/sh
cc -Wall -Wextra -Werror -c ft_putchar.c ft_swap.c ft_putstr.c ft_strlen.c \
ft_strcmp.c
ar rcs libft.a ft_putchar.o ft_swap.o ft_putstr.o ft_strlen.o ft_strcmp.o
El cc -c compila cada .c a un objeto .o (código máquina,
pero sin enlazar). El ar rcs empaqueta esos objetos en un solo archivo
libft.a.
.c → un .o con el código de sus funciones)
y enlazar (juntar los .o y resolver quién llama a quién). Una
librería .a es, literalmente, un archivo (eso es ar, de
archiver, el mismo linaje que tar) que agrupa varios .o para no
ir pasándolos sueltos. La s de rcs escribe un índice de símbolos para que
el enlazador encuentre rápido cada función. "Estática" quiere decir que, al enlazar, el código de
las funciones que uses se copia dentro de tu ejecutable (frente a las dinámicas
.so, que se cargan aparte al arrancar). Es el primer paso para dejar de reescribir
ft_strlen en cada proyecto.El mismo resultado que el script, pero con un Makefile: busca las fuentes en
srcs/, la cabecera en includes/, compila con
-Wall -Wextra -Werror y crea libft.a. Sin recompilar de más, sin
wildcards.
NAME = libft.a
CC = cc
CFLAGS = -Wall -Wextra -Werror
INCLUDES = -I includes
SRCS = srcs/ft_putchar.c srcs/ft_swap.c srcs/ft_putstr.c \
srcs/ft_strlen.c srcs/ft_strcmp.c
OBJS = $(SRCS:.c=.o)
all: $(NAME)
$(NAME): $(OBJS)
ar rcs $(NAME) $(OBJS)
%.o: %.c
$(CC) $(CFLAGS) $(INCLUDES) -c $< -o $@
clean:
rm -f $(OBJS)
fclean: clean
rm -f $(NAME)
re: fclean all
.PHONY: all clean fclean re
make y su grafo de dependencias — El
script del ejercicio anterior recompila todo cada vez. En un proyecto grande eso es
insoportable. make resuelve el problema con un grafo de dependencias:
cada objetivo (libft.a) depende de unos prerequisitos (los .o), y cada
.o depende de su .c. Antes de rehacer algo, make compara las
fechas de modificación: si el .c no ha cambiado desde que se generó el .o,
no lo recompila. Por eso al tocar un solo fuente solo se recompila ese, y volver a ejecutar
make sin cambios responde "nothing to be done". Las reglas clean (borra
los .o), fclean (borra también la librería) y re (todo de
cero) son la convención de 42. La regla %.o: %.c es un patrón: "para hacer
cualquier .o, compila su .c", con $< = el prerequisito y
$@ = el objetivo. Y el aviso "cuidado con los wildcards": listar las fuentes a mano en
vez de *.c evita que un archivo de sobra se cuele en la compilación.Partir una cadena en trozos usando cualquier carácter de un charset como separador, y
devolver un array de cadenas terminado en NULL. Sin trozos vacíos.
char **ft_split(char *str, char *charset);
La solución se descompone en piezas pequeñas (Norma: máximo 25 líneas por función): detectar si
un carácter es separador, contar cuántas palabras hay, duplicar una palabra reservando su tamaño
exacto, y rellenar el array. Se reserva sitio para nº palabras + 1 y la última entrada
se pone a NULL como centinela.
ft_split es el ejercicio
donde convergen casi todos los conceptos previos: punteros a puntero (char **, un
array de cadenas), memoria dinámica (un malloc para el array y uno por cada palabra),
recorrer cadenas con centinela, y descomponer un problema en funciones cortas para respetar la
Norma. La regla "sin cadenas vacías" obliga a pensar los casos borde: separadores al principio, al
final, o varios seguidos ("saca las conclusiones pertinentes", dice el enunciado con retranca).
Contar primero y reservar exacto — en vez de ir agrandando el array — es el patrón de dos pasadas
que evita realloc y fugas.Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a la sección
donde está explicado a fondo. Están agrupadas en: la librería, el Makefile y
ft_split. Antes de mirar la respuesta, intenta contestar tú.
-c del script?Para compilar sin enlazar: cada .c da su .o y no se intenta crear un
ejecutable. Sin -c, cc intentaría enlazar los cinco archivos en un
programa, y fallaría con undefined reference to `main' porque ninguno tiene
main. → ex00, archivo objeto
ar rcs? ¿Qué significa cada letra?Empaqueta los .o en libft.a. r: añade o reemplaza los
.o; c: crea el archivo sin avisar si no existe; s: escribe el
índice de símbolos que usa el enlazador. ar t libft.a enseña lo que hay dentro.
→ librería estática
cc main.c -L. -lft, con la cabecera incluida en main.c. La librería va
después de los archivos que la usan: con cc -L. -lft main.c da
undefined reference to `ft_putstr', porque el enlazador va de izquierda a derecha y,
cuando pasa por la librería, todavía nadie ha pedido nada. → enlazado
La estática (.a) se copia dentro del ejecutable al enlazar: el programa no la
necesita después, pero cada programa lleva su copia. La dinámica (.so) se carga al
arrancar: los ejecutables son más pequeños y comparten una sola copia, pero tiene que estar
instalada donde se ejecuta. → ex00
make dos veces seguidas, ¿qué pasa?La segunda no hace nada: make: Nothing to be done for 'all'. Todos los
.o son más nuevos que sus .c y la librería más nueva que los
.o. Si recompilara, incumpliría «no debe compilar los archivos inútilmente».
→ ex01, dependencias
ft_swap.c?Recompila srcs/ft_swap.o y vuelve a hacer el ar, nada más: es el único
.o cuyo prerequisito es más nuevo, y la librería depende de él. Se comprueba con
touch srcs/ft_swap.c y make. → dependencias
includes/ft.h?Con el Makefile de esta página, nada: ft.h no es prerequisito de ninguna
regla, y make responde Nothing to be done. Para el ejercicio basta (el
enunciado solo habla de fuentes), pero la respuesta honesta es que habría que añadir la cabecera como
prerequisito de los .o, por ejemplo %.o: %.c includes/ft.h.
→ dependencias
clean, fclean y re?clean borra los .o; fclean hace clean y además
borra libft.a; re es fclean seguido de all,
reconstruir desde cero. Se encadenan poniendo una regla como prerequisito de otra
(fclean: clean, re: fclean all). → ex01
.PHONY?Para decirle a make que all, clean, fclean y
re no son archivos. Si no, basta un archivo llamado clean en la carpeta
para que make clean responda 'clean' is up to date y no borre nada.
→ .PHONY
SRCS = $(wildcard srcs/*.c)?Porque la variable SRCS compilaría lo que haya en la carpeta y no lo que pide el enunciado: un archivo de pruebas
se colaría en la librería y uno que faltara no daría error. El enunciado avisa de los wildcards y la
Moulinette prueba el Makefile con sus propios archivos. → wildcard
ft_split con separadores al principio, al final o repetidos, o con una cadena hecha solo de separadores?Solo las palabras: con ",,a," y ",", un array con "a" y
NULL. Con una cadena vacía o hecha solo de separadores, un array con un único elemento
NULL (no un puntero NULL: el array existe y está vacío). Una palabra
empieza donde un no separador sigue a un separador o al principio.
→ ex02, palabra y separador
malloc hace y qué pasa si falla uno a mitad?Uno para el array (palabras + 1 punteros) y uno por palabra (longitud + 1 bytes). Si falla
uno a mitad, lo ya reservado se queda sin liberar si solo se devuelve NULL; el enunciado
solo autoriza malloc, así que hay que saber explicar qué se pierde y cómo se arreglaría
con free. → dos pasadas, fuga