C Piscine — C 09

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).

La introducción — El enunciado cita un fragmento de Proyecto Hail Mary de Andy Weir: un profesor humano y un alienígena (un "eridiano") intentan construir un vocabulario común a base de gestos, empezando por "sí" y "no" y liándose enseguida. Cierra con la coletilla de siempre: "este enunciado no tiene nada que ver con el aprendizaje del eridiano". El paralelo es fino — este módulo va justamente de eso: darle a la máquina un vocabulario (reglas de make) para que sepa qué construir y cómo.

GGlosario de teoría

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.

Compilar y enlazar

Compilación (de .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.

Archivo objeto (.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
Símbolo y undefined reference

Un 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'
Enlazado y enlazador (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'.

Librería estática (.a) y ar rcs

Un 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.

Script de shell

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.

make

Makefile: regla, objetivo, prerequisitos y receta

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».

Grafo de dependencias y fechas de modificación

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.

Regla de patrón y variables automáticas (%.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.

Variables de make y la sustitución $(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.

.PHONY

Declara 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.

Wildcard (comodín)

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.

Cadenas y memoria (ft_split)

char **: puntero a puntero y array de cadenas

Una 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.

Memoria dinámica: malloc

malloc(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.

Centinela NULL

Un 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.

Patrón de dos pasadas: contar y luego reservar

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.

Palabra, separador y cadena vacía

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.

Fuga de memoria (leak)

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.

ex00libft

Entregables: libft_creator.sh + 5 .cFunciones: write

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.

Qué es una librería estática — Compilar un programa tiene dos fases: compilar (cada .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.

ex01Makefile

Entregable: MakefileReglas: all, clean, fclean, re

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
Por qué existe 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.

ex02ft_split

Entregable: ft_split.cFunciones: malloc

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.

El clásico que lo junta todo — 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.

?Preguntas probables de la evaluación

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ú.

La librería

¿Para qué sirve el -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

¿Qué hace 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

¿Cómo se usa la librería desde un programa?

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

¿Qué diferencia hay entre una librería estática y una dinámica?

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

El Makefile

¿Y si modifico solo 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

¿Y si modifico 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

¿Qué diferencia hay entre 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

¿Para qué sirve .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

¿Por qué no pones 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

¿Qué devuelve tu 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

¿Cuántos 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