El primer proyecto del common core: una librería estática, libft.a, con
43 funciones escritas a mano. Media libc rehecha desde cero, once utilidades nuevas para cadenas y
descriptores, y una lista enlazada genérica con t_list — todo empaquetado con un
Makefile y ar.
malloc,
free, write…). Libft es la respuesta: escribes tú
strlen, memcpy o split una vez, bien, y a partir de ahí las
enlazas en ft_printf, get_next_line o push_swap. El enunciado (versión 19.3, camino 42next) la
divide en tres partes obligatorias: Parte 1, funciones de la libc con el mismo
prototipo y el mismo comportamiento que dice su man, pero con prefijo
ft_; Parte 2, funciones adicionales que no están en la libc o están
de otra forma; y Parte 3, listas enlazadas. En esta versión las
ft_lst* ya no son bonus: son funciones normales, en ficheros ft_lstX.c,
compiladas por el make de siempre. Las reglas técnicas pesan tanto como el código:
nada de variables globales, auxiliares siempre static, todo en la raíz del repo,
-Wall -Wextra -Werror, ar obligatorio (libtool prohibido), cero leaks y
ningún segfault fuera del comportamiento indefinido. Y un README.md con descripción, instrucciones,
recursos y uso de IA, que este repo incluye.Libft es el primer contacto serio con cómo C guarda las cadenas, la memoria y los números, y con cómo se compila y se empaqueta una librería. Aquí está cada término explicado desde cero y con un ejemplo sacado de esta libft. 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.
ASCII es la tabla que asigna un número a cada carácter: del 0 al 127, con los de control
('\n' es el 10, '\t' el 9), el espacio en el 32, los dígitos del 48 al 57,
las mayúsculas del 65 al 90 y las minúsculas del 97 al 122. Para C un char es solo un
número pequeño, así que 'a' + 1 es 'b'. EOF es un valor
especial (normalmente -1) que devuelven las funciones de lectura cuando no queda nada que leer; no es
ningún carácter de la tabla.
Por eso las ft_is* reciben un int: tienen que aceptar cualquier byte y
también EOF. ft_isprint es el rango 32..126 (del espacio a la
~), ft_isascii el 0..127, y ft_toupper suma
'A' - 'a' (que vale -32) en vez de escribir el número a mano. ft_atoi
salta los espacios del 9 al 13: \t \n \v \f \r.
'\0')En C una cadena es una fila de char que acaba en el byte '\0' (valor 0).
No se guarda la longitud: el final se sabe porque ahí está el cero. "hola" ocupa 5
bytes, no 4, y por eso toda función que crea una cadena reserva longitud + 1.
ft_strlen cuenta hasta el '\0' sin incluirlo; ft_strdup y
ft_substr reservan l + 1 y escriben el cero al final;
ft_strchr(s, '\0') devuelve un puntero al terminador, porque el man dice que
cuenta como parte de la cadena. Las mem*, en cambio, ignoran los ceros: trabajan con
n bytes exactos.
constUn calificador que promete que algo no se va a modificar a través de ese nombre. En
const char *s lo constante son los caracteres apuntados: s++ está
permitido, *s = 'x' no compila. Sirve de documentación (la función no te va a tocar la
cadena) y de red: el compilador avisa si lo intentas.
ft_strchr(const char *s, int c) promete no tocar s pero devuelve un
char * dentro de ella, así que tiene que quitar el const con el cast
(char *) s. Es el prototipo de la libc y hay que copiarlo tal cual.
unsigned char y bytes con signoUn byte puede leerse como signed char (-128..127) o como unsigned char
(0..255). Un char a secas es uno u otro según la plataforma; en x86 tiene signo. El
mismo byte 0x80 vale -128 con signo y 128 sin signo, y eso cambia el resultado de
cualquier comparación o resta.
El man de strncmp y memcmp pide comparar sin signo, y por
eso ft_strncmp resta (unsigned char) s1[i] - (unsigned char) s2[i]:
ft_strncmp("\200", "a", 1) da positivo, igual que la de la libc (probado). Las
mem* convierten el void * a unsigned char * por lo mismo: así
cada byte es un número de 0 a 255.
void *: memoria sin tipoUn puntero genérico: guarda una dirección pero no dice qué hay en ella. Cualquier puntero se
convierte a void * y de vuelta sin cast, pero no se puede desreferenciar
(*p) ni avanzar (p + 1), porque no se sabe cuántos bytes ocupa cada
elemento. Antes de usarlo hay que decidir cómo leerlo.
Las mem* reciben void * para trabajar con cualquier memoria y lo primero
que hacen es p = dest con unsigned char *p. El content de
t_list también es void *: la lista no sabe qué guarda, y por eso necesita
que le pases del para liberarlo.
size_t y la vuelta de los sin signosize_t es el tipo entero sin signo que usa C para tamaños: lo devuelve
sizeof, lo recibe malloc y en Linux de 64 bits va de 0 a 2⁶⁴ - 1. Al no
tener negativos, una resta que «debería» dar -1 da la vuelta y sale el número más grande posible.
Esa vuelta está definida por el estándar (aritmética módulo 2⁶⁴), así que no da error: da un
resultado enorme y silencioso.
Es la fuente de los bordes más delicados de libft: en ft_strlcpy,
siz - 1 con siz == 0 copiaría sin límite, por eso ese caso va primero. En
ft_memmove se recorre hacia atrás con i = n; while (i > 0) { i--; … },
porque while (i >= 0) con size_t es siempre cierto.
Dos zonas de memoria se solapan cuando comparten bytes, por ejemplo dos trozos del mismo array. Si copias de una a otra en el sentido equivocado, sobrescribes bytes del origen antes de haberlos leído.
Con m = "123456", ft_memmove(m + 1, m, 4) da "112346"
(probado): como el destino está por delante, copia del último byte al primero. Un bucle hacia delante
leería un '1' ya copiado en cada paso y daría "111116".
memcpy no promete nada con zonas solapadas; memmove sí.
malloc y freeEl heap (montículo) es la zona de memoria que el programa pide y devuelve a mano mientras
se ejecuta. malloc(n) reserva n bytes y devuelve su dirección, o NULL si no
puede; free(p) los devuelve. Lo que se reserva ahí sobrevive al final de la función que
lo pidió, al contrario que las variables locales, que viven en la pila de llamadas y desaparecen al
salir.
Por eso ft_strdup, ft_substr o ft_lstnew pueden devolver
memoria nueva: está en el heap. Y por eso cada malloc va seguido de
if (!p) return (NULL). ft_calloc añade el poner a cero con
ft_bzero.
No es una palabra del lenguaje sino una forma de razonar: en cada momento, cada bloque del heap tiene un dueño, el trozo de código que debe liberarlo. Si nadie es dueño, se pierde (una fuga); si lo son dos, se libera dos veces.
En libft, las funciones que reservan pasan la propiedad al llamante: quien llama a
ft_split debe liberar cada palabra y luego el array. En las listas, la lista es dueña de
sus nodos, pero el contenido lo libera del, que pone el llamante. Y en
ft_lstmap hay un momento en que el content recién creado por
f no es de ningún nodo: por eso se libera aparte si falla ft_lstnew.
free y valgrindUna fuga (leak) es memoria reservada que ya no se puede liberar porque no queda
ningún puntero hacia ella. Un doble free es liberar dos veces el mismo bloque: es
comportamiento indefinido, y glibc suele abortar el programa con free(): double free
detected. Valgrind ejecuta el programa vigilando cada malloc y cada
free y avisa de las dos cosas.
Un main de prueba que llama a ft_split, ft_itoa,
ft_strtrim y ft_substr y libera lo que recibe pasa
valgrind --leak-check=full sin ningún aviso. El README cuenta que una versión anterior
de ft_lstmap tenía un doble free en el camino de error.
Lo que el estándar de C no define: leer fuera de un array, desreferenciar NULL,
liberar dos veces, desbordar un int con signo. El programa puede funcionar, dar basura o
caerse, y puede cambiar de un compilador a otro. El enunciado pide que no haya segfaults «salvo
comportamiento indefinido»: si te pasan NULL donde la libc tampoco lo acepta, no se te
exige nada.
Ejemplos en esta libft: ft_strlen(NULL) se cae, igual que strlen; el
ft_strnstr lee big hasta su '\0' aunque len sea
menor, que con un buffer sin terminador sería leer fuera; y ft_lstmap con
del nulo llamaría a un puntero nulo si falla un malloc.
INT_MINLa forma en que el procesador guarda los enteros con signo. Con 32 bits, un int va de
INT_MIN = -2147483648 a INT_MAX = 2147483647: hay un negativo más que
positivos, porque el 0 ocupa un hueco de la mitad positiva. Consecuencia: -INT_MIN no
cabe en un int.
Es el borde que más se evalúa en libft. ft_putnbr_fd lo resuelve copiando a
long antes de negar; ft_itoa y ft_atoi, sin long:
trabajan con el número en negativo y nunca calculan +2147483648.
ft_itoa(-2147483648) da "-2147483648" (probado).
Pasa cuando el resultado de una operación no cabe en el tipo. Con signo (int) es
comportamiento indefinido; sin signo (size_t) da la vuelta y sigue como si nada. Lo
peligroso es que no avisa: el programa sigue con un número equivocado.
En ft_calloc, nmemb * size puede no caber en 64 bits: el producto daría
la vuelta, se reservaría un bloque diminuto y quien lo use escribiría fuera. Por eso se comprueba
s / nmemb != size: ft_calloc((size_t)-1, 2) devuelve NULL
(probado).
Desde C99, la división entera trunca hacia cero: 7 / -2 da -3, no -4. Y el resto
lleva el signo del dividendo: -7 % 10 da -7. Se cumple siempre que
(a / b) * b + a % b == a.
ft_itoa se apoya en eso para no negar nunca el número: con un n
negativo, n % 10 está entre -9 y 0, así que -(n % 10) es el dígito.
Con -2147483648 la última cifra es -(-8) = 8.
En C los argumentos se copian: la función recibe su propia copia de cada parámetro, y cambiarla no afecta a la variable del llamante. Para que una función cambie algo de fuera, hay que pasarle su dirección y escribir a través de ella.
En ft_lstadd_back, la rama lst = &new; cambia la copia local de
lst y no tiene ningún efecto fuera. ft_striteri pasa
&s[i] precisamente para que f pueda cambiar el carácter, mientras que
ft_strmapi pasa el carácter por valor.
t_list **)Un puntero a un puntero. Si el llamante tiene t_list *lista y la función debe
cambiar a qué nodo apunta lista (porque cambia la cabeza o la deja a
NULL), tiene que recibir &lista, de tipo t_list **, y
escribir en *lst. Es el paso por valor aplicado a un puntero.
Lo usan las tres funciones que pueden cambiar la cabeza: ft_lstadd_front (el nodo
nuevo pasa a ser la cabeza), ft_lstadd_back (si la lista estaba vacía) y
ft_lstclear (la deja a NULL). ft_lstsize o
ft_lstlast solo leen y reciben t_list *. ft_split devuelve
un char **, un array de punteros a cadenas.
Una variable que guarda la dirección de una función, para llamarla después. Se declara con la
forma de la función: void (*del)(void *) es «un puntero llamado del a una
función que recibe un void * y no devuelve nada». Se llama con del(x) o
(*del)(x), que son equivalentes.
Permite que la librería deje una parte del trabajo a quien la usa: ft_strmapi y
ft_striteri reciben qué hacer con cada carácter, ft_lstiter y
ft_lstmap qué hacer con cada contenido, y ft_lstdelone y
ft_lstclear cómo liberarlo (para un content hecho con
malloc, basta pasar free).
Hay dos formas clásicas de usarlo para recorrer una colección: map construye una
colección nueva con los resultados y deja la original intacta (ft_strmapi,
ft_lstmap); for-each llama a la función con cada elemento y no devuelve nada,
y si algo cambia, cambia en el sitio (ft_striteri, ft_lstiter).
staticUna función declarada static solo es visible dentro de su fichero .c:
el enlazador no la ve desde fuera y no choca con otra del mismo nombre en otro fichero. El enunciado
obliga a que todas las auxiliares lo sean, y el tester del pack comprueba que todo símbolo global
empiece por ft_.
Las auxiliares de libft son static: ft_trim_r y
ft_trim_l en strtrim, las cuatro de split y ft_char_init e
ft_itoa_real en itoa. Con nm libft.a salen con una t
minúscula (locales) y las 43 públicas con T.
&& y || evalúan de izquierda a derecha y se paran en cuanto
saben el resultado: en A && B, si A es falso, B ni se evalúa. Así se escriben
condiciones en las que la segunda parte solo es segura si la primera se cumple.
ft_memchr hace while (i < n && p[i] != c): con
i == n el byte p[n] no llega a leerse. ft_lstlast hace
while (n && n->next != NULL), y por eso acepta una lista vacía. Si se
invierte el orden, la lectura se hace antes de comprobar el límite.
Una función es recursiva si 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 un trozo de la pila de llamadas, y si se anidan demasiadas, se agota (stack overflow).
Esta libft tiene tres: ft_putnbr_fd (imprime n / 10 antes que su
último dígito), ft_itoa_real (el caso base, el dígito más alto, reserva la cadena) y
ft_lstclear (borra el resto de la lista antes que el nodo actual). Las dos primeras se
anidan como mucho 10 veces; ft_lstclear, una vez por nodo.
Una forma de escribir un recorrido: el programa está siempre en uno de unos pocos
estados y cada cosa que lee lo hace pasar de uno a otro. En vez de muchos if
anidados, una variable dice «dónde estoy».
ft_count_words y ft_add_word usan dos estados, «fuera de palabra» (0) y
«dentro» (1), guardados en una variable (f en ft_count_words, i[1] en ft_add_word). Un carácter distinto de c pasa de 0 a 1 y
marca el inicio; un c o el '\0' pasan de 1 a 0 y cierran la palabra. Por
eso " a bb ccc " da a, bb y ccc sin palabras
vacías (probado).
Una secuencia hecha de nodos sueltos en memoria, cada uno con su dato y un puntero al siguiente;
el último apunta a NULL. La lista se maneja con un puntero al primer nodo (la cabeza),
y una lista vacía es simplemente ese puntero a NULL.
Frente a un array, meter un nodo al principio es inmediato (ft_lstadd_front son dos
asignaciones), pero llegar al final exige recorrerla entera: ft_lstlast,
ft_lstsize y ft_lstadd_back caminan hasta NULL. El
t_list de libft es simple (cada nodo solo conoce al siguiente) y genérico
(void *content).
La notación O grande dice cómo crece el trabajo cuando crece la entrada, sin fijarse en constantes. O(1) es coste fijo; O(n), proporcional al tamaño (el doble de nodos, el doble de trabajo); O(n²), proporcional al cuadrado (el doble de nodos, cuatro veces más).
ft_lstadd_front es O(1); ft_lstadd_back es O(n), porque recorre la
lista para encontrar el último. ft_lstmap llama a ft_lstadd_back por cada
nodo sobre una lista que va creciendo: 1 + 2 + … + n pasos, O(n²). Guardando un puntero al último
nodo sería O(n).
Un número entero con el que el sistema operativo identifica algo abierto por el proceso: un
fichero, una tubería, la terminal. Todo proceso arranca con tres: 0 es la entrada estándar (stdin),
1 la salida estándar (stdout) y 2 la salida de errores (stderr). write(fd, buf, n)
escribe n bytes en el que le digas.
Las ft_put*_fd reciben el descriptor como parámetro: ft_putstr_fd("hola", 1)
escribe en pantalla, con 2 va a stderr (lo que no se cuela en una tubería |), y con el
número que devuelve open iría a un fichero.
.o)El resultado de compilar un .c sin enlazarlo (cc -c): código máquina
de sus funciones más una tabla de símbolos con lo que define y lo que necesita de fuera. Todavía no
se puede ejecutar, porque las llamadas a funciones de otros ficheros están sin resolver.
El Makefile compila cada ft_*.c a su .o por separado. nm -u
sobre la librería lista lo que necesitan de fuera: solo malloc, free,
write y __stack_chk_fail, que la añade el compilador para proteger la
pila, no el código.
arUna librería estática (.a) es un archivo que guarda varios ficheros objeto juntos con
un índice de qué símbolo está en cuál. Al enlazar un programa con ella, se copian dentro del
ejecutable los objetos que hacen falta y nada más. La alternativa es una librería dinámica
(.so), que se carga al ejecutar.
ar rcs libft.a *.o la crea: r inserta o reemplaza, c crea
el archivo sin avisar y s escribe el índice. ar t libft.a lista los 43
objetos, y nm -s enseña el índice (ft_isalpha in ft_isalpha.o…).
-L, -l, -I)El enlazador (linker) es la última fase de la compilación: junta los ficheros objeto y
las librerías y resuelve cada llamada a la dirección de su función. Si falta una, da
undefined reference. -I dice dónde buscar los headers (eso es del
compilador), -L dónde buscar librerías y -lft que use
libft.a: el nombre sin lib ni extensión.
Para usar libft: cc main.c -I. -L. -lft. El orden importa: la librería va después de
los ficheros que la usan, porque el enlazador solo saca de ella lo que ya sabe que falta.
Una regla de Makefile dice qué fichero se construye (objetivo), de qué depende y con
qué comando. make solo ejecuta el comando si el objetivo no existe o alguna dependencia
es más nueva. Se dice que un Makefile relinkea cuando un segundo make sin
cambios vuelve a compilar o a crear la librería: en 42 cuenta como fallo.
Aquí libft.a depende de los .o y cada .o de su
.c y de libft.h. Un segundo make responde Nothing to be
done for 'all'; tras touch ft_strlen.c recompila solo
ft_strlen.o y vuelve a pasar ar (probado). .PHONY marca
all, clean, fclean y re como reglas que no son
ficheros.
Un #ifndef NOMBRE / #define NOMBRE / #endif que envuelve un
header para que, si se incluye dos veces en el mismo .c (directa o indirectamente), la
segunda vez quede vacía. Sin él, el typedef de t_list se definiría dos
veces y no compilaría.
libft.h empieza con #ifndef LIBFT_H y # define LIBFT_H
(la Norma pide sangrar con un espacio tras la # lo que va dentro del guard) e incluye
<unistd.h> y <stdlib.h>, que dan size_t,
write, malloc y free.
La Norma es el estilo obligatorio de 42 para C, y norminette el programa que la
comprueba. Entre otras cosas: funciones de 25 líneas como mucho, 5 funciones por fichero, 4
parámetros y 5 variables por función, declaraciones al principio y separadas del código, nada de
for, switch ni do while, y tabuladores para indentar. Un error
de norma es un 0 en la evaluación.
Explica varias decisiones del código: que ft_split se parta en cuatro auxiliares, o
que ft_add_word guarde sus cuatro contadores en int i[4] para ahorrar
líneas. norminette sobre el repo da OK en todos los ficheros.
Siete funciones de una comparación. Todas reciben un int (no un
char, para poder recibir EOF) y, según el enunciado, las de clasificación
devuelven exactamente 1 o 0:
int ft_isalpha(int c)
{
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
return (1);
else
return (0);
}
int ft_isalnum(int c)
{
if (ft_isdigit(c) || ft_isalpha(c))
return (1);
else
return (0);
}
int ft_toupper(int c)
{
if (c >= 'a' && c <= 'z')
return (c + 'A' - 'a');
return (c);
}
ft_isprint usa el rango c > 31 && c < 127 (del espacio a
la ~) y ft_isascii el 0..127. ft_isalnum
reutiliza las otras dos en lugar de repetir los rangos. Ojo, una rareza de estilo: los cinco
ft_is*.c incluyen <unistd.h> en vez de "libft.h", y
ft_isalnum.c declara a mano los prototipos de ft_isalpha y
ft_isdigit; compila igual, pero el resto del repo tira del header común.
man y respetar el tipo exacto (int, no char) y el valor de
retorno exacto. El truco de c + 'A' - 'a' evita escribir el número 32 a pelo: expresa
la distancia entre mayúsculas y minúsculas en términos de la propia tabla ASCII.char *ft_strchr(const char *s, int c)
{
char *p;
p = (char *) s;
while (*p != (char) c && *p)
p++;
if (*p == (char) c)
return (p);
return (NULL);
}
char *ft_strrchr(const char *s, int c)
{
char *p;
p = ((char *) s) + ft_strlen(s);
while (*p != (char)c && p != s)
p--;
if (*p != (char) c && p == s)
return (NULL);
else
return (p);
}
Dos detalles que pide el man y que el código cumple. El '\0' final
cuenta como parte de la cadena: ft_strchr(s, '\0') devuelve un puntero al terminador,
porque el bucle para en él y la comparación final acierta. Y c se convierte a
(char) antes de comparar, así que ft_strchr(s, 'a' + 256) encuentra la
'a'. ft_strrchr va al revés: empieza en el terminador y retrocede
hasta encontrar c o chocar con el principio.
(char *) s es el
primer choque con const: la libc recibe una cadena que promete no modificar pero
devuelve un char * modificable dentro de ella. Es una decisión histórica del estándar
(si devolviese const char * sería incómoda de usar con cadenas no constantes) y aquí
te toca reproducirla tal cual.int ft_strncmp(const char *s1, const char *s2, size_t n)
{
size_t i;
if (n == 0)
return (0);
i = 0;
while (s1[i] && s2[i] && s1[i] == s2[i] && i < n && i < n - 1)
i++;
if (i != n)
return ((unsigned char) s1[i] - (unsigned char) s2[i]);
return (0);
}
La resta se hace con unsigned char: el man exige comparar los bytes como
sin signo, de modo que '\200' sea mayor que 'a' y no un número
negativo. El bucle se detiene en n - 1 para que la última comparación sea la del
carácter n-ésimo. Ojo, una rareza inofensiva: i < n sobra (lo implica
i < n - 1) y, como el bucle nunca deja i == n, el
return (0) final nunca se ejecuta.
i = 0;
while (p[i])
{
j = 0;
while (i + j < len && q[j] && p[i + j] && p[i + j] == q[j])
j++;
if (!(q[j]))
return (&p[i]);
i++;
}
return (NULL);
ft_strnstr busca little dentro de los primeros len
caracteres de big: por cada posición de salida intenta casar la aguja entera sin
pasarse de len. Ojo: el bucle exterior solo para en el '\0' de
big, no en len. El resultado es correcto (pasado len el bucle
interior no avanza y nunca hay coincidencia), pero sigue leyendo big hasta su final;
con un buffer que no tenga '\0' dentro de los len bytes, leería fuera.
unsigned char y el límite len. Las funciones "con n" de
la libc existen para trabajar con memoria cuyo tamaño conoces, y el reto es que ese límite se
respete en todas las lecturas, no solo en el resultado.Las copias "seguras" de BSD: reciben el tamaño total del buffer destino
(siz), nunca escriben más allá, siempre terminan en '\0' si hay sitio, y
devuelven la longitud de la cadena que intentaron crear. Si el valor devuelto es
>= siz, hubo truncado.
size_t ft_strlcpy(char *dst, const char *src, size_t siz)
{
size_t i;
if (siz == 0)
return (ft_strlen(src));
i = 0;
while (i < siz - 1 && src[i])
{
dst[i] = src[i];
i++;
}
dst[i] = '\0';
return (ft_strlen(src));
}
El caso siz == 0 va primero por una razón concreta: siz es
size_t, y siz - 1 con siz == 0 no da -1, da el
size_t máximo — el bucle copiaría sin límite.
size_t ft_strlcat(char *dst, const char *src, size_t siz)
{
size_t n_dst;
size_t i;
n_dst = 0;
while (n_dst < siz && dst[n_dst])
n_dst++;
if (n_dst == siz)
return (siz + ft_strlen(src));
n_dst = ft_strlen(dst);
i = 0;
while (i + n_dst < siz - 1 && src[i])
{
dst[n_dst + i] = src[i];
i++;
}
dst[n_dst + i] = '\0';
return (n_dst + ft_strlen(src));
}
ft_strlcat tiene la trampa famosa: si en los primeros siz bytes de
dst no hay '\0', el destino "no cabe" y debe devolver
siz + strlen(src) sin tocar nada. Por eso el primer bucle mide dst
acotado por siz en lugar de llamar a ft_strlen sin más. Superado
ese filtro se sabe que siz > n_dst, así que siz - 1 ya no puede dar la
vuelta. Ejemplo: con dst = "abc", siz = 6 y src = "defghijkl"
queda "abcde" y devuelve 12.
size_t no existen los negativos, y cada resta hay que justificarla antes de
escribirla. También el diseño del valor de retorno: devolver "lo que habría ocupado" permite
detectar el truncado y reservar lo justo en un segundo intento. strlcpy ya apareció en
C 02; aquí se le suma strlcat y el caso degenerado del
destino lleno. El enunciado recuerda que glibc no las trae: para compararlas hace falta
<bsd/string.h> y -lbsd.Las mem* no saben nada de cadenas: trabajan con n bytes de memoria
cualquiera, recibida como void *, y no se paran en ningún '\0'. Lo primero
que hacen todas es convertir ese puntero genérico en unsigned char * para poder
recorrerlo byte a byte:
void *ft_memcpy(void *dest, const void *src, size_t n)
{
unsigned char *p;
const unsigned char *q;
size_t i;
if (dest == NULL && src == NULL)
return (dest);
p = dest;
q = src;
i = 0;
while (i < n)
{
p[i] = q[i];
i++;
}
return (dest);
}
La guarda dest == NULL && src == NULL imita lo que hace la libc del sistema
con dos punteros nulos (no hacer nada) y es la que suelen comprobar los testers.
ft_memset y ft_bzero son el mismo bucle escribiendo
(unsigned char) c o 0. En ft_memchr la condición
i < n va antes que la lectura del byte, de modo que nunca toca
p[n]:
while (i < n && (unsigned char) p[i] != (unsigned char)c)
i++;
if (i == n)
return (NULL);
else
return (&p[i]);
void * es "memoria sin
tipo": no se puede desreferenciar ni hacer aritmética con él, hay que decidir cómo leerlo. Y que el
orden de las condiciones de un && importa: la evaluación en cortocircuito es
lo que garantiza que la comprobación del límite proteja la lectura. El README del propio repo
menciona justo ese fallo (leer p[n] tras el bucle de memchr) entre los que hubo que
corregir, y un test que coloca los buffers pegados a una página de memoria protegida para cazar
lecturas fuera de rango.memcpy no garantiza nada si origen y destino se solapan; memmove sí.
El problema: si copias hacia delante y el destino empieza dentro del origen, machacas
bytes que aún no has leído.
void *ft_memmove(void *dest, const void *src, size_t n)
{
unsigned char *p;
const unsigned char *q;
size_t i;
if (dest == NULL && src == NULL)
return (NULL);
p = dest;
q = src;
if (dest > src)
{
i = n;
while (i > 0)
{
i--;
p[i] = q[i];
}
}
else
return (ft_memcpy(dest, src, n));
return (dest);
}
La solución es elegir el sentido de la copia. Si dest está por detrás de
src, copiar de delante hacia atrás es seguro y se delega en ft_memcpy. Si
dest está por delante, se copia de atrás hacia delante: el último byte primero, así los
que se sobrescriben ya se han leído. Con "123456" y
ft_memmove(m + 1, m, 4) sale "112346"; un memcpy ingenuo daría
"111116". El patrón i = n; while (i > 0) { i--; … } evita el clásico
while (i >= 0), que con size_t sería un bucle infinito.
> solo
está garantizado por el estándar dentro del mismo objeto; en la práctica todas las implementaciones
de memmove hacen esto mismo.) while (nptr[i] == ' ' || (nptr[i] >= 9 && nptr[i] <= 13))
i++;
if (nptr[i] == '+' || nptr[i] == '-')
{
if (nptr[i] == '-')
s = -s;
i++;
}
while (nptr[i] >= '0' && nptr[i] <= '9' && nptr[i])
{
r = r * 10 + s * (nptr[i] - '0');
i++;
}
return (r);
Espacios (incluidos \t \n \v \f \r, del 9 al 13), un único signo opcional y
dígitos. Lo interesante es r * 10 + s * digito: el signo se aplica a cada dígito en
lugar de al final, de modo que con "-2147483648" el acumulador va bajando por los
negativos y llega a INT_MIN sin pasar nunca por +2147483648, que no cabe
en un int. La condición && nptr[i] sobra: un dígito ya no es
'\0'.
INT_MIN resuelto acumulando con signo. La lección de
fondo es la de siempre: el rango del complemento a dos es asimétrico.void *ft_calloc(size_t nmemb, size_t size)
{
void *p;
long s;
if (nmemb == 0 || size == 0)
return (malloc(0));
s = nmemb * size;
if (nmemb != 0 && s / nmemb != size)
return (NULL);
p = (void *)malloc(sizeof(char) * s);
if (!p)
return (NULL);
ft_bzero(p, nmemb * size);
return (p);
}
calloc tiene dos responsabilidades además de poner a cero: (1) detectar que
nmemb * size desborda — si al dividir el producto entre nmemb no sale
size, la multiplicación dio la vuelta y se devuelve NULL en lugar de
reservar un trozo diminuto; y (2) la regla que añade el enunciado: con nmemb o
size a 0 debe devolver un puntero único que se pueda pasar a free. El
código delega en malloc(0), que en glibc cumple eso (aunque el estándar permite que
devuelva NULL). Ojo, una rareza: s es long y no
size_t; la comprobación funciona igual porque en s / nmemb el
long se convierte a size_t, pero el tipo natural sería
size_t. El nmemb != 0 es redundante tras el primer if.
ft_strdup es el de C 07:
ft_strlen, malloc(l + 1), comprobar NULL, copiar y cerrar con
'\0'.
char *ft_substr(char const *s, unsigned int start, size_t len)
{
char *p;
size_t i;
if (ft_strlen(s) < start)
len = 0;
if (len > ft_strlen(s) - (size_t) start)
len = ft_strlen(s) - (size_t) start;
p = (char *)malloc(sizeof(char) * (len + 1));
…
Antes de reservar, len se recorta a lo que de verdad queda desde
start, para no pedir un megabyte cuando alguien llama
ft_substr("hola", 1, 1000000). Si start está más allá del final, se
devuelve una cadena vacía reservada (no NULL), que es lo que esperan los testers. Ojo
al segundo if: cuando start se pasa, la resta
ft_strlen(s) - start da la vuelta y vale un número enorme; no rompe nada porque
len ya es 0 y la comparación sale falsa, pero funciona más por suerte del orden que por
diseño.
ft_strjoin mide las dos cadenas, reserva l1 + l2 + 1 y copia una
detrás de otra escribiendo en p[l1 + i].
NULL, rellenar, terminar en '\0'. Y que
el llamante es quien libera: cada una de estas funciones devuelve memoria nueva cuya propiedad pasa
a quien la llamó, como ya se vio con join en C 07.static int ft_trim_r(char const *s1, char const *set)
{
int l;
l = ft_strlen(s1) - 1;
while (l > 0 && ft_strchr(set, s1[l]))
l--;
return (l);
}
static int ft_trim_l(char const *s1, char const *set, int l)
{
int i;
i = 0;
while (i < l + 1 && ft_strchr(set, s1[i]))
i++;
return (i);
}
…
l = ft_trim_r(s1, set);
i = ft_trim_l(s1, set, l);
return (ft_substr(s1, i, l - i + 1));
Primero se busca desde la derecha el último carácter que no está en set, luego desde
la izquierda el primero, sin cruzarse con el anterior, y se extrae lo de en medio con
ft_substr. "Estar en el set" se resuelve reutilizando ft_strchr. La cadena
vacía se trata aparte (reserva un ""), porque ft_strlen(s1) - 1 daría -1.
Cuando todo s1 está formado por caracteres del set, i acaba en
l + 1 y la longitud l - i + 1 es 0: sale "".
static para cumplir las 25 líneas
de la Norma.La función más larga del proyecto, partida en cuatro auxiliares static. Dos pasadas
sobre la cadena: una para contar palabras y reservar el array de punteros, otra para copiar cada
palabra.
char **ft_split(char const *s, char c)
{
char **r;
size_t n_str;
n_str = ft_count_words(s, c);
r = (char **)malloc(sizeof(char *) * (n_str + 1));
if (!r)
return (0);
if (ft_add_word(s, r, c))
return (r);
else
return (NULL);
}
Contar y copiar usan la misma máquina de dos estados: un indicador "estoy dentro de una palabra"
que pasa a 1 al ver un carácter distinto de c y vuelve a 0 al ver c o el
final. El bucle es while (1) con break después de procesar el
'\0', para que la última palabra se cierre al llegar al terminador:
static int ft_add_word(char const *s, char **r, char c)
{
int i[4];
ft_bzero(i, sizeof(i));
while (1)
{
if (s[i[0]] && s[i[0]] != c && i[1] == 0)
{
i[1] = 1;
i[2] = i[0];
}
else if ((s[i[0]] == c || !s[i[0]]) && i[1] == 1)
{
i[1] = 0;
r[i[3]] = ft_word_dup(s, i[2], i[0]);
if (!r[i[3]])
return (ft_free_split(r));
i[3]++;
}
if (!s[i[0]])
break ;
i[0]++;
}
r[i[3]] = NULL;
return (1);
}
Las cuatro variables van en un array int i[4] puesto a cero con
ft_bzero: i[0] recorre la cadena, i[1] es el estado,
i[2] marca dónde empezó la palabra e i[3] es el índice en el resultado.
Es un recurso para que la función quepa en las 25 líneas de la Norma (cuatro declaraciones y cuatro
inicializaciones se quedan en dos líneas), a costa de legibilidad.
static int ft_free_split(char **r)
{
int i;
i = 0;
while (r[i])
{
free(r[i]);
i++;
}
free(r);
return (0);
}
La gestión del fallo es la parte que se evalúa: si un ft_word_dup devuelve
NULL, ese mismo NULL ya está escrito en r[i[3]], así que
ft_free_split libera exactamente las palabras anteriores, luego el array, y
ft_split devuelve NULL sin fugas. Con " a bb ccc " y
' ' salen a, bb, ccc — separadores repetidos o
en los extremos no generan palabras vacías.
NULL dejando medio
resultado colgado en el heap. Es el split de C 07 simplificado
a un único separador, pero ahora con la liberación en caso de error como requisito explícito.Una solución recursiva poco habitual: la recursión baja dígito a dígito contando la profundidad
d, y es el caso base (el dígito más significativo) quien sabe ya cuántas cifras tiene el
número y reserva la cadena. Al volver, cada nivel escribe su dígito en su posición.
static char *ft_itoa_real(int n, int d)
{
char *r;
int dd;
int neg;
neg = (n < 0);
if (n / 10 != 0)
r = ft_itoa_real(n / 10, d + 1);
else
{
r = (char *)malloc(sizeof(char) * (d + 2 + neg));
if (!r)
return (NULL);
r = ft_char_init(r, d + 1 + neg);
}
if (!r)
return (NULL);
dd = ft_strlen(r);
if (neg)
{
r[0] = '-';
r[dd - 1 - d] = -(n % 10) + '0';
}
else
r[dd - 1 - d] = n % 10 + '0';
return (r);
}
char *ft_itoa(int n)
{
return (ft_itoa_real(n, 0));
}
Si el número tiene d + 1 cifras, el caso base reserva d + 1 bytes más
el signo más el '\0', y ft_char_init lo rellena de '0' para que
ft_strlen(r) dé la longitud final desde el principio. El nivel de profundidad
d escribe en r[dd - 1 - d]: el nivel 0 (las unidades) en la última
posición, y así hacia la izquierda.
El INT_MIN se resuelve sin long: el número nunca se niega.
Se divide tal cual, negativo, y en C99 n % 10 de un negativo es negativo (o cero), así
que -(n % 10) es un dígito entre 0 y 9. Con -2147483648 la última cifra
es -(-8) = 8 y no hace falta calcular +2147483648. Los casos
0, -5, INT_MAX e INT_MIN dan la cadena
correcta. Un fallo de malloc en el caso base se propaga hacia arriba con los
if (!r) return (NULL).
/ y
% con negativos (truncamiento hacia cero) deja de ser un detalle del estándar para
convertirse en la herramienta que evita el desbordamiento. r = (char *)malloc(sizeof(char) * (l + 1));
if (!r)
return (NULL);
i = 0;
while (i < l)
{
r[i] = (*f)((unsigned int)i, (char)s[i]);
i++;
}
r[i] = '\0';
void ft_striteri(char *s, void (*f)(unsigned int, char *))
{
…
if (s && f)
{
l = ft_strlen(s);
i = 0;
while (i < l)
{
f((unsigned int)i, &s[i]);
i++;
}
}
}
Las dos recorren la cadena y llaman a f con el índice y el carácter. La diferencia
es la de map frente a for-each: ft_strmapi recibe el carácter por
valor y construye una cadena nueva con lo que devuelve f; ft_striteri le
pasa la dirección del carácter (&s[i]) para que f lo cambie en
el sitio, y no reserva nada. Las dos sintaxis de llamada, (*f)(…) y f(…),
son equivalentes en C. ft_striteri protege s y f nulos;
ft_strmapi no.
lstmap de lstiter en la Parte 3.void ft_putstr_fd(char *s, int fd)
{
write(fd, s, ft_strlen(s));
}
void ft_putnbr_fd(int n, int fd)
{
char d;
long nl;
nl = n;
if (n < 0)
{
write(fd, "-", 1);
nl = -nl;
}
if (nl / 10 != 0)
ft_putnbr_fd(nl / 10, fd);
d = nl % 10 + '0';
write(fd, &d, 1);
}
Las funciones de salida de la piscine, ahora con el descriptor como parámetro: 1 para stdout,
2 para stderr o el fd de un fichero abierto. ft_putstr_fd hace un solo
write con la longitud entera en vez de uno por carácter, y
ft_putendl_fd reutiliza ft_putstr_fd y añade el '\n'.
ft_putnbr_fd es el putnbr de C 00: copia a
long antes de negar para que INT_MIN quepa, y recursión para imprimir los
dígitos en orden (al volver a llamarse con nl / 10, el long se convierte
en int sin pérdida, porque ya es positivo y menor).
fd es lo que permite,
más adelante, mandar los errores a stderr o escribir en un fichero con las mismas funciones.libft.h:
typedef struct s_list
{
void *content;
struct s_list *next;
} t_list;
Es la misma idea que el t_list de C 12 con otros
nombres (content en lugar de data): un nodo que se apunta a sí mismo y un
void * que permite guardar cualquier cosa. En la versión 42next estas nueve funciones
forman parte de la parte obligatoria, como las demás; no hay ficheros _bonus ni regla
bonus. Un cambio respecto a versiones anteriores del enunciado: ft_lstsize
devuelve unsigned int, y así está en el código.t_list *ft_lstnew(void *content)
{
t_list *n;
n = (t_list *)malloc(sizeof(t_list));
if (!n)
return (NULL);
else
{
n->content = content;
n->next = NULL;
return (n);
}
}
void ft_lstadd_front(t_list **lst, t_list *new)
{
if (lst && new)
{
new->next = *lst;
*lst = new;
}
}
t_list *ft_lstlast(t_list *lst)
{
t_list *n;
n = lst;
while (n && n->next != NULL)
n = n->next;
return (n);
}
Las cuatro piezas básicas. ft_lstnew no copia content: guarda el
puntero tal cual. ft_lstadd_front recibe t_list ** porque tiene que
cambiar la cabeza del llamante. ft_lstlast admite una lista vacía (devuelve
NULL) gracias al n &&, y ft_lstsize es el recorrido
canónico while (n) { n = n->next; i++; }.
void ft_lstadd_back(t_list **lst, t_list *new)
{
t_list *n;
if (!lst)
{
lst = &new;
}
else if (!(*lst))
{
n = NULL;
*lst = new;
}
else
{
n = *lst;
while (n->next != NULL)
n = n->next;
n->next = new;
}
}
Tres casos: puntero a lista nulo, lista vacía (el nuevo nodo pasa a ser la cabeza) y lista con
nodos (se camina hasta el último y se engancha). El comportamiento es correcto, pero ojo a dos
líneas que no hacen nada: lst = &new; cambia la copia local del parámetro
lst, que se pierde al salir de la función (el efecto real de esa rama es "no hacer
nada", que es lo razonable), y n = NULL; asigna una variable que no se vuelve a usar.
Además, como hay que recorrer la lista entera, añadir al final cuesta O(n).
*lst = …), no reasignar el puntero mismo. Y que en una lista simple sin
puntero a la cola, "el final" siempre está a n pasos.void ft_lstdelone(t_list *lst, void (*del)(void *))
{
if (lst && del)
{
del(lst->content);
free(lst);
}
}
void ft_lstclear(t_list **lst, void (*del)(void *))
{
if (lst && *lst && del)
{
if ((*lst)->next)
ft_lstclear(&((*lst)->next), del);
del((*lst)->content);
free(*lst);
*lst = NULL;
}
}
Liberar un nodo son dos free distintos: el del contenido, que hace
del porque solo el llamante sabe qué hay detrás del void *, y el del
propio nodo. ft_lstclear está hecha con recursión: primero borra el resto de la lista
desde el siguiente, luego el nodo actual, y deja el puntero del llamante a NULL como
pide el enunciado. Así se evita el problema clásico de perder next al liberar un nodo.
Ojo: cada nodo es un nivel de recursión, así que con una lista muy larga (cientos de miles de nodos)
la pila podría desbordarse; una versión iterativa que guarde next antes de liberar no
tiene ese límite.
ft_lstiter aplica f al contenido de cada nodo; el bucle se detiene en el
último nodo y lo procesa aparte después, en lugar del más directo
while (n) { f(n->content); n = n->next; }, con el mismo resultado.
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *))
{
t_list *r;
t_list *n;
void *content;
if (!lst || !f)
return (NULL);
r = NULL;
while (lst)
{
content = f(lst->content);
n = ft_lstnew(content);
if (!n)
{
del(content);
ft_lstclear(&r, del);
return (NULL);
}
ft_lstadd_back(&r, n);
lst = lst->next;
}
return (r);
}
Construye una lista nueva aplicando f a cada contenido, sin tocar la original. Lo
delicado es el camino de error. Si ft_lstnew falla, hay dos cosas en el aire:
el content que f acaba de crear y que todavía no pertenece a ningún nodo
(por eso se libera aparte con del(content)), y los nodos ya construidos en
r, que ft_lstclear borra junto con sus contenidos. Guardar el resultado de
f en una variable antes de crear el nodo es lo que permite liberarlo; la versión que
hace ft_lstnew(f(lst->content)) en una línea lo pierde. El README del repo cuenta que
una versión anterior tenía aquí un doble free.
Ojo a dos detalles. Se comprueba que f no sea NULL pero no
del: si del es NULL y falla un malloc, la llamada
del(content) se haría sobre un puntero nulo. Y como cada nodo se añade con
ft_lstadd_back, que recorre r desde el principio, construir la lista cuesta
O(n²); guardar un puntero al último nodo lo dejaría en O(n).
ft_free_split de split, en una estructura
enlazada.NAME = libft.a
CC = cc
CFLAGS = -Wall -Wextra -Werror
SRCS = ft_isalpha.c ft_isdigit.c ft_isalnum.c ft_isascii.c ft_isprint.c \
…
ft_lstnew.c ft_lstadd_front.c ft_lstsize.c \
ft_lstlast.c ft_lstadd_back.c ft_lstdelone.c \
ft_lstclear.c ft_lstiter.c ft_lstmap.c
OBJS = $(SRCS:.c=.o)
all: $(NAME)
$(NAME): $(OBJS)
ar rcs $(NAME) $(OBJS)
%.o: %.c libft.h
$(CC) $(CFLAGS) -c $< -o $@
clean:
rm -f $(OBJS)
fclean: clean
rm -f $(NAME)
re: fclean all
.PHONY: all clean fclean re
Cada ft_*.c se compila por separado a su .o, y ar rcs los
mete en un archivo: r inserta o reemplaza los objetos, c crea el archivo
sin avisar y s escribe el índice de símbolos que usa el enlazador. libft.a
depende de los .o y cada .o de su .c y de
libft.h, así que un segundo make no recompila nada (no hay relink) y tocar
el header recompila todo. Las listas van en SRCS como cualquier otra función: no hay
regla bonus. libft.h lleva include guard
(#ifndef LIBFT_H), el typedef de t_list y los 43 prototipos.
Para usarla, como explica el README: cc main.c -I. -L. -lft, donde
-lft busca libft.a (o libft.so) en las rutas de
-L.
ft_strlen, solo entra ft_strlen.o. Las dependencias del Makefile son lo
que C 09 empezó y aquí se vuelve obligatorio: compilar solo lo
que cambió.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: funciones de la libc, memoria dinámica, listas, Makefile y normas, y puntos débiles. Antes de mirar la respuesta, intenta contestar tú.
memcpy y memmove?Que memmove funciona aunque origen y destino se solapen.
ft_memmove mira dónde está el destino: si está por delante del origen, copia del último
byte al primero; si no, delega en ft_memcpy, que copia hacia delante. Con
"123456" y ft_memmove(m + 1, m, 4) sale "112346".
→ memmove
strlcat y para qué sirve ese valor?La longitud de la cadena que intentó crear: strlen(dst) + strlen(src), o
siz + strlen(src) si en los primeros siz bytes de dst no hay
'\0'. Si el valor es >= siz, hubo truncado, y sabes cuánto reservar para
el segundo intento. Con "abc", siz = 6 y "defghijkl" queda
"abcde" y devuelve 12. → strlcpy / strlcat
ft_atoi con " -42abc", "+-5" y "-2147483648"?-42, 0 y -2147483648. Salta los espacios (del 9 al 13 y el 32), admite un signo y lee
dígitos hasta el primero que no lo sea. "+-5" tiene dos signos y el segundo ya no es un
dígito. INT_MIN sale bien porque el signo se aplica a cada dígito
(r * 10 + s * dígito) y el acumulador nunca pasa por +2147483648.
→ atoi, complemento a dos
ft_strncmp resta como unsigned char?Porque el man pide comparar los bytes sin signo. Con char, que en x86
tiene signo, '\200' valdría -128 y saldría menor que 'a'; con
unsigned char vale 128 y sale mayor, como en la libc. → strncmp,
unsigned char
ft_calloc además de poner a cero?Dos cosas. Detecta que nmemb * size desborda: si al
dividir el producto entre nmemb no sale size, devuelve NULL
(ft_calloc((size_t)-1, 2) da NULL). Y con nmemb o
size a 0 devuelve malloc(0), que en glibc es un puntero válido para
free, como pide el enunciado. → calloc
malloc a mitad de ft_split, ¿hay fugas?No. El NULL de la palabra que falló queda escrito en r[i[3]], así que
ft_free_split recorre el array hasta ese NULL liberando las palabras
anteriores, libera el array y ft_split devuelve NULL. Si falla el
malloc del array, devuelve NULL sin haber reservado nada más.
→ split
ft_itoa cuánta memoria reservar, y cómo trata INT_MIN?La recursión baja dígito a dígito contando la profundidad
d; el caso base (el dígito más alto) ya sabe que hay d + 1 cifras y
reserva d + 2 bytes más uno si es negativo. INT_MIN no se niega nunca: se
divide en negativo y cada dígito sale de -(n % 10). → itoa,
división con negativos
ft_lstadd_front recibe t_list ** y ft_lstsize t_list *?Porque ft_lstadd_front cambia la cabeza de la lista del llamante, y en C los
parámetros se pasan por valor: para cambiar su puntero necesita su
dirección y escribir en *lst. ft_lstsize solo lee. →
lstnew, lstadd_front…, doble puntero
del?El content es un void *: la lista no sabe qué hay detrás ni cómo se
libera. del es un puntero a función que pone quien
creó el contenido (para un content reservado con malloc, vale
free). ft_lstdelone llama a del(content) y después libera el
nodo. → lstdelone, lstclear
ft_lstmap si falla ft_lstnew?Dos cosas: el content que f acaba de crear y que aún no está en ningún
nodo (del(content)), y la lista nueva construida hasta ahí
(ft_lstclear(&r, del)). La original no se toca. Por eso el resultado de
f se guarda en una variable antes de crear el nodo. → lstmap
ar rcs?No: libft.a depende de los .o y cada .o de su
.c y de libft.h, así que un segundo make dice Nothing to
be done for 'all', y si tocas un .c solo se recompila ese. ar rcs
mete los objetos en el archivo (r), lo crea sin avisar (c) y escribe el
índice de símbolos (s). Para usarla: cc main.c -I. -L. -lft.
→ Makefile, relink
No y sí. nm -u libft.a solo lista malloc, free,
write y __stack_chk_fail (esta la pone el compilador). Todas las
auxiliares son static, así que los únicos símbolos globales son
las 43 ft_. Y norminette da OK en todos los ficheros; la Norma es la razón
de que ft_split tenga cuatro auxiliares y un int i[4].
→ split, la Norma
lst = &new; de ft_lstadd_back?Nada útil: cambia la copia local del parámetro, que se pierde al salir. El efecto de esa rama es
no hacer nada cuando lst es NULL, que es lo razonable, pero la línea
sobra; igual que el n = NULL; de la rama siguiente. Además añadir al final es O(n),
y por eso ft_lstmap acaba siendo O(n²). → lstadd_back
ft_strnstr el límite len en todas las lecturas?No del todo. El resultado es correcto, pero el bucle exterior solo para en el '\0' de
big, no en len: sigue leyendo big hasta el final. Con un
buffer sin '\0' dentro de los len bytes leería fuera. El arreglo es añadir
i < len a esa condición. Algo parecido en ft_lstmap: no comprueba que
del no sea NULL. → strnstr,
lstmap