El módulo de la memoria dinámica: por primera vez tus funciones reservan memoria con
malloc y devuelven arrays y cadenas de tamaño desconocido en tiempo de compilación.
Duplicar cadenas, generar rangos, unir, convertir bases y partir por separadores.
malloc y el
ownership — Hasta ahora toda tu memoria era automática: variables locales y
arrays de tamaño fijo que viven en la pila (stack) y desaparecen solos al salir de la
función. El problema: una función no puede devolver un array local, porque al terminar ese array ya no
existe — devolverías la dirección de memoria basura. Cuando el tamaño se decide en ejecución
(¿cuántos enteros hay entre min y max? ¿cuántas palabras tiene esta cadena?)
necesitas otra región: el heap (montón). malloc(n) te reserva n bytes
del heap y te devuelve su dirección; esa memoria vive hasta que tú la liberas con
free. De ahí nacen las dos reglas que este módulo te mete en el cuerpo. Primera: reservas
el tamaño exacto, y por eso escribes malloc(sizeof(int) * n) o
sizeof(char) * (len + 1) — el +1 es para el '\0' que cierra
toda cadena, y sizeof pregunta al compilador cuánto ocupa cada elemento en esta
máquina en vez de asumir 4 u 8. Segunda: el ownership (propiedad). Cuando una función devuelve
memoria del heap, el que la llama hereda la obligación de liberarla; si nadie lo hace, esa
memoria queda reservada para siempre y tienes una fuga (memory leak). Los tests de
este módulo comprueban tanto el contenido como que todo lo que reservas se pueda free-ar.
(El prólogo lista las criaturas del Donjon de Naheulbeuk — zombis, arañas gigantes, papel
higiénico, raviolis; humor de rol francés, sin relación con el ejercicio.)C 07 es el módulo en el que la memoria deja de ser automática: hay que pedirla, medirla, llenarla y saber quién la devuelve. Aquí está cada término explicado 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.
Un programa en marcha guarda sus datos en dos zonas principales. La pila (stack) es donde viven las variables locales: se reservan solas al entrar en una función y desaparecen solas al salir. El heap (montón) es memoria que se pide a mano, del tamaño que haga falta en ese momento, y que dura hasta que se devuelve a mano.
Por eso ft_range no puede devolver un int r[5] local: al volver, esa
memoria de la pila ya no es suya. Tiene que pedirla al heap con malloc, y esa sí sigue
existiendo cuando quien la llamó la recibe.
malloc(n) reserva n bytes en el heap y devuelve la dirección del
primero, como void * (un puntero «a cualquier cosa» que se puede asignar a un
char * o a un int *). Los bytes reservados no están a cero: contienen lo que
hubiera antes. Si no puede reservar, devuelve NULL.
En C 07 es la única función autorizada en casi todos los ejercicios. ex04 permite además
free.
NULL es un puntero que no apunta a nada; se usa para decir «no hay resultado». Si
malloc falla y no lo compruebas, el código siguiente escribe en NULL y el
programa muere con un segfault.
En el repo, ft_strdup, ft_ultimate_range y ft_strjoin
comprueban el malloc; ft_range no, y ft_split solo comprueba el
del array, no el de cada palabra. NULL también es parte del contrato de ex01: con
min >= max se devuelve NULL a propósito.
sizeof(tipo) dice cuántos bytes ocupa un tipo en la máquina donde se compila. Lo
calcula el compilador, no cuesta nada en ejecución. Aquí: sizeof(char) es 1 siempre,
sizeof(int) es 4 y sizeof(char *) es 8.
Como malloc cuenta en bytes, para 5 enteros hay que pedir sizeof(int) * 5,
20 bytes, y no 5. El array de ft_split se pide con sizeof(char *).
Una cadena de C acaba en el byte '\0', que no cuenta en su longitud pero ocupa sitio.
Por eso una copia de una cadena de longitud len necesita len + 1 bytes.
"hola" tiene longitud 4 y ocupa 5.
Sale en ex00 (malloc(sizeof(char) * (i + 1))), en ex03, en cada palabra de ex05
(i[0] - i[2] + 1) y en ex04 con el signo: d + 2 + neg cuenta las cifras,
el '\0' y el - si hace falta.
free(p) devuelve al sistema la memoria que reservó malloc. Solo se puede
llamar con un puntero que salió de malloc (o con NULL, que no hace nada) y
una sola vez: liberar dos veces lo mismo es un double free, y usar la memoria después de
liberarla es otro error.
Las funciones de C 07 no liberan lo que devuelven: lo libera quien las llama. Para el resultado
de ft_split hay que hacer free de cada palabra y después del array.
Memoria reservada con malloc que nadie libera y a la que ya no apunta ningún puntero:
sigue ocupada pero no se puede usar ni devolver. En un programa que acaba enseguida no se nota; en
uno que funciona horas o reserva en un bucle, se come la memoria.
Un caso que pide atención en ex05: si el malloc de una palabra fallara a mitad, lo
correcto sería liberar las palabras ya creadas y el array antes de devolver NULL; si
no, se pierden.
Quién tiene la obligación de liberar un bloque. No es algo que C controle: es un acuerdo que hay
que cumplir. La regla de C 07: la función que reserva y devuelve memoria pasa la propiedad
a quien la llama, que es quien tiene que hacer el free.
Por eso el enunciado de ex03 insiste en que, con size == 0, se devuelva una cadena
vacía «que pueda liberarse con free()»: quien llama va a hacer free sin mirar, y
tiene que ser memoria de malloc, no un "" literal.
Una herramienta que ejecuta tu programa vigilando cada acceso a memoria. Avisa de lecturas o
escrituras fuera de lo reservado, de memoria usada sin inicializar y, al acabar, de los bloques que
no se liberaron. Se usa así: valgrind --leak-check=full ./a.out.
Con un main que llama a las seis funciones del repo y libera todo lo que recibe,
valgrind -q --leak-check=full no informa de ningún error ni fuga.
Un puntero es una dirección. dst = src copia la dirección: los dos nombres apuntan a
los mismos bytes, y si cambias uno, cambia «el otro». Duplicar una cadena es reservar memoria nueva y
copiar en ella los bytes uno a uno.
Es la diferencia entre ex00 y una asignación. Con el repo, ft_strdup("hola") devuelve
un bloque nuevo con hola que se puede modificar o liberar sin tocar el original.
Una función de C solo devuelve un valor con return. Para «devolver» algo más, quien
llama le pasa la dirección de una variable suya y la función escribe ahí. Si esa variable
es a su vez un puntero, lo que se pasa es un puntero a puntero: int **.
En ex02 se llama así: int *u; n = ft_ultimate_range(&u, 5, 8);. Después
n vale 3 y u apunta a 5 6 7. Con (8, 5),
n vale 0 y u queda en NULL.
En C los corchetes se aplican antes que el *. *range[i] significa
*(range[i]): tomar la casilla i de range como si fuera un array
de punteros y luego seguirla. (*range)[i] es lo que se quiere en ex02: seguir
range hasta el puntero del llamador y tomar la casilla i de su array.
Con i = 0 las dos coinciden; con i = 1, *range[1] lee
memoria que no es tuya.
Un char ** como el que devuelve ft_split es un array cuyas casillas son
punteros a cadenas. Para que quien lo recibe sepa dónde acaba sin que le digan el tamaño, la última
casilla vale NULL: un centinela. Por eso se reserva una casilla de más.
Con el repo, ft_split(" hola,,mundo ;fin ", ", ;") da
["hola", "mundo", "fin", NULL], y ft_split("", ",") un array con solo el
NULL.
La forma de escribir un número con un conjunto de símbolos. En base 10 se usan diez cifras y cada
posición vale diez veces más que la de su derecha; en base 2, dos cifras y cada posición vale el
doble; en base 16, dieciséis (0123456789abcdef). El número es el mismo, cambia cómo se
escribe: 255 en decimal es ff en hexadecimal y 11111111 en binario.
En ex04 la base es una cadena: su longitud es cuántos símbolos hay y la posición de cada símbolo
es lo que vale. Con "01", '1' vale 1.
Las reglas vienen de ft_putnbr_base y ft_atoi_base: al menos dos
símbolos, ninguno repetido y ninguno que sea +, - o un espacio en blanco.
Con un solo símbolo no se puede escribir nada, con símbolos repetidos una cifra tendría dos valores, y
los signos y espacios se confundirían con el número.
ft_base_ok del repo devuelve 0 si la base no vale y su longitud si vale. Con
"0", "0+1" y "011" como base de destino,
ft_convert_base devuelve NULL.
Convertir texto en número: se saltan los espacios del principio, se cuentan los signos (cada
- cambia el signo) y se leen cifras mientras pertenezcan a la base, haciendo en cada una
resultado = resultado · base + cifra. Al primer carácter que no es de la base se para.
Con "--42" en decimal, los dos menos se anulan y sale 42, que en octal es
52. Con " \t-+-2a" en hexadecimal sale 42 y en binario
101010. Con "12x9", la lectura para en la x y queda 12.
El camino inverso: la última cifra es el resto de dividir entre la base, y el resto del número es el cociente. Se repite hasta que el cociente es 0. Las cifras salen de derecha a izquierda, así que hay que colocarlas desde el final o usar recursión, que las deja en orden a la vuelta.
ft_itoa_base del repo es recursiva: baja hasta la cifra más alta, reserva ahí la
cadena (ya sabe cuántas cifras hay, porque ha contado la profundidad d) y cada nivel
escribe su cifra al volver. Con negativos usa -(n % b), porque en C el resto de un
negativo es negativo. "-2147483648" a hexadecimal da -80000000.
Un int va de −2147483648 a 2147483647. Si el texto representa un número más grande,
el acumulador desborda, que en C es comportamiento indefinido, y sale un valor sin sentido.
El enunciado de ex04 lo resuelve por contrato: «el número representado por nbr debe caber dentro de
un entero». El repo acumula en int, y con "2147483648" devuelve
-2147483648; es una entrada que el enunciado deja fuera.
Para usar en un archivo una función escrita en otro, basta con declarar su prototipo
(int ft_strlen(char *s);) y compilar los dos juntos. Lo que no puede haber es la
misma función pública definida en dos archivos que se enlazan juntos: el enlazador da
multiple definition.
ex04 obliga a partir el código en dos archivos: ft_strlen y
ft_char_init viven en ft_convert_base2.c y ft_convert_base.c
los declara arriba. Y el error se puede provocar: enlazar juntos el ex00 y el ex03 del repo da
multiple definition of `ft_strlen', porque los dos la definen.
Un separador es un carácter que marca dónde acaba una palabra y empieza otra. En ex05
charset no es una cadena que haya que encontrar entera: es un conjunto, y cada
uno de sus caracteres separa por sí solo. Varios separadores seguidos son un único corte, así que no
salen palabras vacías.
Con ", ;", en " hola,,mundo ;fin " separan los espacios, las comas y el
punto y coma. Con charset vacío no separa nada (el repo solo corta en el
'\0') y "a b" sale como una sola palabra.
Reproducir strdup: reservar una cadena nueva y copiar en ella src,
devolviendo la copia.
char *ft_strdup(char *src)
{
char *dst;
int i;
dst = (char *)malloc(sizeof(char) * (ft_strlen(src) + 1));
if (!dst)
return (NULL);
i = 0;
while (src[i])
{
dst[i] = src[i];
i++;
}
dst[i] = '\0';
return (dst);
}
Tres pasos que se repetirán todo el módulo: medir (ft_strlen), reservar el tamaño
justo (+1 para el terminador), copiar y cerrar con '\0'. Y siempre,
comprobar que malloc no devolvió NULL antes de escribir.
dst = src: eso copiaría el puntero (dos nombres para los
mismos bytes), no el contenido. Duplicar significa pedir memoria propia y copiar byte a byte. Es el
"hola mundo" de la gestión de memoria: si esto lo tienes claro, el resto del módulo son variaciones.Devolver un array con todos los enteros de min a max, incluyendo
min y excluyendo max. Si min >= max, devolver NULL.
int *ft_range(int min, int max)
{
int *arr;
int i;
int size;
if (min >= max)
return (NULL);
size = max - min;
arr = (int *)malloc(sizeof(int) * size);
if (!arr)
return (NULL);
i = 0;
while (i < size)
{
arr[i] = min + i;
i++;
}
return (arr);
}
El tamaño se calcula: max - min elementos. Al ser un array de enteros, se reserva
sizeof(int) * size — no size a secas: cada int ocupa varios
bytes.
int arr[size] local moriría al volver. Y que el tamaño de la
reserva se cuenta en bytes, de ahí sizeof(int). También el contrato de errores: ante
entrada inválida (min >= max) devuelves NULL, y quien te llama tendrá que
comprobarlo antes de usar el resultado — el mismo patrón que malloc usa contigo.Igual que ex01 pero el array se devuelve por parámetro (int **range) y la
función devuelve el tamaño, o -1 si falla el malloc. Si
min >= max, deja *range en NULL y devuelve 0.
int ft_ultimate_range(int **range, int min, int max)
{
int i;
int size;
if (min >= max)
{
*range = NULL;
return (0);
}
size = max - min;
*range = (int *)malloc(sizeof(int) * size);
if (!*range)
return (-1);
i = 0;
while (i < size)
{
(*range)[i] = min + i;
i++;
}
return (size);
}
El doble puntero int **range es la clave: el llamador pasa la dirección de su propio
puntero, y la función escribe en él con *range = …. Así la función devuelve dos
cosas: el array (por el parámetro) y el tamaño (por el return). Ojo a los paréntesis en
(*range)[i]: primero se deshace un nivel de indirección, luego se indexa.
return y las demás por punteros de salida — aquí llevado a un doble
puntero porque lo que se rellena es, a su vez, un puntero. Es exactamente el patrón de
ft_div_mod de C01, pero con memoria dinámica de por medio. Entender (*range)[i]
frente a *range[i] (que significaría otra cosa por la precedencia) es la clase de detalle
de punteros que separa "compila por suerte" de "sé lo que escribo".Concatenar las size cadenas de strs usando sep entre ellas.
Si size == 0, devolver una cadena vacía que se pueda free-ar.
char *ft_strjoin(int size, char **strs, char *sep)
{
char *res;
char *p;
int i;
res = (char *)malloc(sizeof(char) * (total_len(size, strs, sep) + 1));
if (!res)
return (NULL);
p = res;
i = 0;
while (i < size)
{
p = ft_append(p, strs[i]);
if (i < size - 1)
p = ft_append(p, sep);
i++;
}
*p = '\0';
return (res);
}
Primero se calcula el tamaño total (suma de las longitudes más la del separador
size - 1 veces), se reserva de una vez, y luego se va copiando. El helper
ft_append copia una cadena y devuelve el puntero justo detrás de lo escrito,
para que la siguiente copia continúe donde acabó la anterior. El separador se pone entre elementos,
nunca después del último (de ahí if (i < size - 1)).
size == 0 no devuelves NULL sino "" — una cadena de un solo byte
('\0') reservada en el heap. Esa distinción entre "no hay resultado" (NULL) y
"el resultado es vacío pero existe y hay que liberarlo" es sutil y muy real: media librería estándar
depende de tratarla bien.Convertir la cadena nbr, escrita en base_from, a su representación en
base_to. Cualquier base inválida ⇒ NULL. Se respetan las reglas de
atoi_base: espacios iniciales, varios signos +/-, y solo un
- como prefijo del resultado.
/* validación de base: longitud >= 2, sin repetidos,
sin '+', '-' ni espacios */
int ft_is_valid_base(char *base);
/* núcleo del pipeline */
char *ft_convert_base(char *nbr, char *base_from, char *base_to)
{
long value;
if (!ft_is_valid_base(base_from) || !ft_is_valid_base(base_to))
return (NULL);
value = ft_atoi_base(nbr, base_from);
return (fill_result(value, base_to, ft_baselen(base_to)));
}
El problema se parte en dos mitades limpias: leer y escribir.
ft_atoi_base lee la cadena en base_from y produce un long
(saltando espacios, aplicando todos los signos, acumulando valor · base + dígito).
fill_result hace lo inverso: toma el número y genera la cadena en base_to
dividiendo repetidamente entre el tamaño de la base, y antepone un único - si es
negativo. El módulo obliga a dos archivos porque no cabe todo en cinco funciones por fichero: los
helpers de validación y lectura viven en ft_convert_base2.c y se declaran como prototipos
en el principal.
printf,
scanf y cualquier serializador. Además concentra las trampas de robustez de toda la
piscine: bases con caracteres repetidos o prohibidos, signos múltiples, el prefijo con un solo
-, y usar long para que el acumulador no se desborde al leer. Y es tu primer
proyecto multi-archivo: aprender a declarar prototipos para compartir funciones entre .c
sin un .h.Partir str en palabras, tratando cada carácter de charset como
separador. Devolver un array de cadenas terminado en NULL, sin cadenas vacías y sin
modificar str.
char **ft_split(char *str, char *charset)
{
char **result;
result = (char **)malloc(sizeof(char *) * (count_words(str, charset) + 1));
if (!result)
return (NULL);
return (fill_words(result, str, charset));
}
Dos pasadas. La primera, count_words, cuenta cuántas palabras hay para reservar el
array de punteros justo (más 1 para el NULL final). La segunda,
fill_words, localiza cada palabra entre separadores y la duplica con
word_dup (un strdup acotado a [inicio, fin)). La regla "sin
cadenas vacías" sale sola de tratar cualquier racha de separadores consecutivos como un único corte:
solo se crea palabra cuando hay al menos un carácter no separador.
char **) y, para cada
casilla, reservas otra cadena (char *) — memoria que apunta a memoria. Y con ello, el
ownership completo: quien recibe el resultado debe liberar primero cada palabra y luego el
array. El centinela NULL al final es lo que permite recorrerlo sin saber su tamaño
(while (result[i])), la misma convención que el '\0' de las cadenas pero un
nivel más arriba. Contar antes de reservar, tratar los separadores consecutivos, respetar la cadena de
entrada: es el ejercicio donde todo C07 (medir, reservar el tamaño exacto, copiar, no fugar) se junta.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. Están agrupadas en: memoria, casos límite, ft_convert_base y puntos débiles.
Las respuestas hablan del código de tu entrega (repo/), que no siempre es el mismo que
se muestra en las tarjetas. Antes de mirar la respuesta, intenta contestar tú.
ft_strdup no puede hacer simplemente return (src);?Porque eso devuelve la misma dirección, no una copia: quien llama podría intentar
free de una cadena que no salió de malloc, o cambiarla creyendo que es suya.
strdup reserva longitud + 1 bytes nuevos y copia el contenido con su
'\0'. → ex00, copiar puntero o contenido
ft_range no devuelve un array local?Porque las variables locales viven en la pila y dejan de existir al volver de la función: se
devolvería una dirección a memoria que ya no es tuya. La memoria de malloc está en el
heap y dura hasta que alguien hace free. → ex01,
pila y heap
Quien las llama: la propiedad pasa con el puntero devuelto. Para ft_split, primero
cada palabra y después el array. Con un main que libera todo, valgrind no informa de
ninguna fuga ni error en las seis funciones. → ownership,
valgrind
ft_ultimate_range recibe un int **?Porque tiene que devolver dos cosas: el tamaño, por return, y el array, escribiéndolo
en el puntero de quien llama. Para cambiar un int * de otra función hace falta su
dirección, un int **. Dentro se escribe (*range)[i], con paréntesis por la
precedencia. → ex02, doble puntero
ft_strjoin con size == 0?Una cadena vacía reservada con malloc(1), que se puede liberar: el enunciado lo exige
así. Con size 0 la longitud total se queda en 0, se reserva 1 byte y solo se escribe el
'\0'. Con {"uno", "dos", "tres"} y ", " sale
uno, dos, tres, sin separador al final. → ex03,
ownership
ft_split? ¿Y con str vacía?Una palabra empieza al pasar de separador a no separador y acaba al volver a un separador (o al
'\0'), así que varios separadores seguidos no crean nada. " hola,,mundo ;fin "
con ", ;" da hola, mundo, fin. Con
"" se devuelve un array con solo el NULL. → ex05,
separador, centinela
ft_convert_base.En dos pasos con un int en medio. ft_atoi_base lee el texto en
base_from (espacios, signos, cifras mientras sean de la base) y
ft_itoa_base lo escribe en base_to de forma recursiva, con un solo
- delante si es negativo. Antes, si alguna base no vale, se devuelve NULL.
"255" de decimal a hexadecimal da ff. → ex04,
atoi_base, itoa_base
" \t-+-2a"?Si tiene menos de dos símbolos, alguno repetido, o un +, un - o un
espacio en blanco: "0", "011" y "0+1" dan NULL.
" \t-+-2a" en hexadecimal: se saltan los espacios, los dos - se anulan y
queda 42, que en binario es 101010. → base válida,
atoi_base
Porque lo pide el enunciado y porque la Norma limita a cinco funciones por archivo: el principal
tiene cinco y ft_strlen y ft_char_init van en
ft_convert_base2.c. El principal las declara con su prototipo arriba y se compilan
juntos. Lo que no puede pasar es definir la misma función en los dos. → ex04,
varios archivos
malloc no devuelva NULL?No en todas. ft_strdup, ft_ultimate_range (devuelve −1),
ft_strjoin y ft_itoa_base sí. ft_range no la comprueba y
escribiría en NULL. ft_split comprueba el array pero no cada palabra, y si
una fallara no libera las anteriores. Además ft_range reserva un int de
más (max - min + 1), inofensivo. → NULL y malloc,
fuga
nbr no cabe en un int?El acumulador desborda: "2147483648" sale como -2147483648. El enunciado
dice que el número debe caber en un entero, así que esa entrada queda fuera del contrato; si se quiere
blindar, se acumula en long. "-2147483648" sí funciona: da
-80000000 en hexadecimal. → overflow