C Piscine — C 07

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.

El concepto que vertebra el módulo: el heap, 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.)

GGlosario de teoría

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.

Memoria dinámica

Pila (stack) y heap

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

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 y comprobar lo que devuelve malloc

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

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

El +1 del terminador '\0'

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

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.

Fuga de memoria (memory leak)

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.

Propiedad de la memoria (ownership)

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.

Valgrind

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.

Punteros

Copiar el puntero frente a copiar el contenido

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.

Puntero de salida y doble puntero (int **)

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.

Precedencia: (*range)[i] frente a *range[i]

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.

Array de punteros con NULL al final (centinela)

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.

Bases y cadenas

Base de numeración

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.

Base válida

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.

Leer un número en una base (atoi_base)

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.

Escribir un número en una base (itoa_base)

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.

Overflow al leer el número

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.

Varios archivos .c, prototipos y multiple definition

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.

Separador y charset

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.

ex00ft_strdup

Entrega: ft_strdup.cAutorizado: malloc

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.

Qué te obliga a aprender — El ciclo de vida de una cadena en el heap y por qué no basta con 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.

ex01ft_range

Entrega: ft_range.cAutorizado: malloc

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.

Qué te obliga a aprender — Que devolver un array desde una función exige heap: un 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.

ex02ft_ultimate_range

Entrega: ft_ultimate_range.cAutorizado: malloc

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.

Qué te obliga a aprender — El idioma clásico de C para "devolver varias cosas": una por 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".

ex03ft_strjoin

Entrega: ft_strjoin.cAutorizado: malloc

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

Qué te obliga a aprender — La estrategia "medir primero, reservar una vez, llenar después", que evita reservar y re-reservar en cada paso. Y el detalle exigido: con 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.

ex04ft_convert_base

Entrega: ft_convert_base.c, ft_convert_base2.cAutorizado: malloc, free

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.

Qué te obliga a aprender — Que "convertir de base" no es una operación: son dos, con un entero como puente. Un número no "está en base 10"; está en la máquina como bits, y las bases solo son formas de escribirlo. Separar el parser (texto→entero) del formateador (entero→texto) es el mismo diseño que hay detrás de 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.

ex05ft_split

Entrega: ft_split.cAutorizado: malloc

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.

Qué te obliga a aprender — El ejercicio cumbre del módulo: memoria dinámica de dos niveles. Reservas un array de punteros (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.

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

Memoria

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

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

¿Quién libera la memoria que devuelven tus funciones? ¿Hay leaks?

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

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

Casos límite

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

¿Cómo evitas las cadenas vacías en 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

Explícame cómo convierte 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

¿Cuándo es inválida una base? ¿Y qué pasa con " \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

¿Por qué dos archivos en ex04, y cómo se ven entre ellos?

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

Puntos débiles (mejor tener la respuesta preparada)

¿Compruebas siempre que 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

¿Qué pasa si 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