C Piscine — C 02

Manipulación de cadenas carácter a carácter. Se reimplementan trozos de la libc (strcpy, strncpy, strlcpy) y se escriben predicados y transformaciones sobre texto. 13 ejercicios (ex00–ex12); todos con funciones autorizadas: ninguna, salvo ex11 y ex12 que pueden usar write.

¿Qué es un char? — El tema de fondo de todo el módulo. Un char no es «una letra»: es un entero de 8 bits (un byte). Cuando escribes 'A', el compilador guarda el número 65; 'a' es 97, '0' es 48. Esa correspondencia es la tabla ASCII, y explica los trucos que se repiten aquí: pasar de mayúscula a minúscula es sumar 32 (la distancia entre 'A' y 'a'), y comprobar «¿es una letra?» es preguntar «¿el número cae en el rango 65–90 o 97–122?». Reimplementar la libc no es reinventar la rueda por gusto: es dejar de tratar strcpy como magia y entender que por dentro solo hay un bucle que copia bytes hasta el \0. En el examen no hay #include <string.h> que te salve.

GGlosario de teoría

C02 va de cadenas, y las cadenas en C son bytes con un poco de convención encima. Aquí está cada palabra que usa la página explicada desde cero y con un ejemplo sacado de los propios ejercicios. 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.

Caracteres y bytes

char: un número pequeño

Un char ocupa un byte (8 bits) y guarda un número entero. Lo que hace que «sea una letra» es solo cómo se interpreta al imprimirlo. 'A' entre comillas simples no es un texto: es otra forma de escribir el número 65.

Por eso se puede comparar y operar con caracteres como con cualquier entero: str[i] >= 'a' es str[i] >= 97, y 'a' - 'A' vale 32.

ASCII

La tabla que asigna un número del 0 al 127 a cada carácter básico: letras sin tilde, dígitos, signos de puntuación y caracteres de control. Es de 1963 y sigue siendo la base de todo, porque UTF-8 (lo que se usa hoy) coincide con ASCII en esos 128 primeros.

Los tramos que usa el módulo:

QuéCaracteresCódigos
Controltabulador, salto de línea…0–31 y 127
Espacio' '32
Dígitos'0'–'9'48–57
Mayúsculas'A'–'Z'65–90
Minúsculas'a'–'z'97–122
Último imprimible'~'126

Entre 'Z' y 'a' hay seis signos ([ \ ] ^ _ `); por eso ft_str_is_alpha no puede usar un solo rango de 'A' a 'z'.

Carácter imprimible y carácter de control

Un carácter imprimible es el que se ve en pantalla: en ASCII, del espacio (32) a la tilde ~ (126). Los de control (0–31 y el 127, DEL) no se dibujan, sino que dan órdenes a la terminal: el 10 ('\n') baja de línea, el 9 ('\t') tabula, el 7 hace sonar un pitido.

ex06 comprueba ese rango; ex11 y ex12 sustituyen los no imprimibles por una representación visible (\0a o .).

Mayúsculas y minúsculas: la distancia de 32

En ASCII cada minúscula está exactamente 32 posiciones por encima de su mayúscula: 'A' es 65 y 'a' 97. Pasar de una a otra es sumar o restar 32, o lo que es lo mismo, 'a' - 'A'. Como 32 es 25, las dos formas solo se diferencian en un bit: 'A' ^ 32 da 'a'.

Solo vale para letras: hay que comprobar el rango antes. Restar 32 a '1' (49) daría el 17, un carácter de control. ex07, ex08 y ex09 hacen siempre las dos cosas.

char con signo y unsigned char

Si char tiene signo o no depende del compilador y la máquina. En los PC de 42 (x86-64 con gcc o clang) tiene signo: va de -128 a 127. Un byte por encima de 127 se ve como negativo: (char)200 vale -56, y (unsigned char)200, 200.

Importa en cuanto aparece un byte que no es ASCII, como las letras con tilde. En ex11, sin el (unsigned char), str[i] / 16 sería negativo y se leería fuera de la tabla "0123456789abcdef".

UTF-8: caracteres de más de un byte

La codificación de casi todo el texto actual. Los caracteres ASCII ocupan un byte, igual que antes; el resto (tildes, eñes, emojis) ocupan de dos a cuatro, todos por encima de 127.

Las funciones de C02 trabajan byte a byte y no saben nada de UTF-8. Con el código de la página, ft_putstr_non_printable("café") imprime caf\c3\a9: la é son dos bytes, 0xc3 y 0xa9, y ninguno cae en 32–126.

Hexadecimal y nibble

Base 16: los dígitos son 0–9 y a–f (10 a 15). Un dígito hex son exactamente 4 bits (un nibble, medio byte), así que un byte se escribe siempre con dos dígitos, de 00 a ff. 0x delante indica hex en C: 0x0a es 10.

Para sacar los dos dígitos de un byte: el alto es byte / 16 y el bajo byte % 16, y cada uno se usa como índice en "0123456789abcdef". Con el salto de línea (10): 10 / 16 = 0 y 10 % 16 = 10, que es a. De ahí el \0a de ex11.

Cadenas

Cadena en C y terminador '\0'

C no tiene tipo cadena: una cadena es una fila de char que acaba en un byte de valor 0, el terminador nulo, y se maneja con un char * a su primer carácter. "Hola" ocupa 5 bytes. El terminador no es el carácter '0' (48), sino el número 0.

Nada guarda la longitud: se sabe dónde acaba una cadena porque se encuentra el 0. Por eso todos los bucles del módulo son while (str[i]), y por eso copiar una cadena sin copiar el terminador da algo que no es una cadena.

Literal de cadena (solo lectura)

Una cadena escrita en el código entre comillas dobles. El compilador la guarda en una zona de memoria de solo lectura, así que char *s = "hola"; ft_strupcase(s); compila pero acaba en segfault al escribir.

Para probar ex07, ex08 y ex09 hay que darles memoria propia: char s[] = "hola"; crea un array y copia el literal dentro, y ese sí se puede modificar.

Predicado y la cadena vacía (verdad vacía)

Un predicado es una función que responde sí o no: aquí, 1 o 0. ex02 a ex06 son predicados sobre una cadena entera: «¿todos los caracteres cumplen X?».

Para la cadena vacía responden 1, y no es un capricho del enunciado: «todos los elementos de un conjunto vacío cumplen X» es verdad en lógica, porque no hay ninguno que lo incumpla. Se llama verdad vacía. En el código sale sola: con "" no se entra en el bucle y se llega al return (1).

Modificar en el sitio (in place)

Cambiar los datos donde están, en vez de crear una copia con el resultado. ex07, ex08 y ex09 escriben sobre el mismo str que reciben y lo devuelven; quien llama ve su cadena cambiada.

Devolver str no es necesario (el que llama ya lo tiene), pero permite encadenar llamadas: ft_putstr(ft_strupcase(s)). Es lo que hacen también strcpy y strncpy con dest.

Desbordamiento de búfer (buffer overflow)

Un búfer es una zona de memoria reservada para guardar datos, como char dest[10]. Se desborda cuando se escribe más allá de su final: C no lo impide, y lo que hay al lado (otras variables, la dirección de vuelta de la función) queda pisado. Es comportamiento indefinido y, durante décadas, la fuente número uno de agujeros de seguridad.

ft_strcpy no conoce el tamaño de dest: si src no cabe, desborda. ft_strncpy y ft_strlcpy reciben un tamaño para no pasarse.

Truncar y detectar el truncamiento

Truncar es cortar: copiar solo lo que cabe. strlcpy lo hace siempre bien (copia como mucho size - 1 caracteres y pone el terminador), y además devuelve la longitud de src completa, no lo copiado.

Así, quien llama sabe si se ha cortado: si el valor devuelto es >= size, no cabía. Ejecutado con el código de ex10: ft_strlcpy(d, "Hola mundo", 6) deja "Hola " en d (5 caracteres y el 0) y devuelve 10.

libc y man

La biblioteca estándar de C: strcpy, strlen, isalpha, printf… Está en todo sistema con C, y sus funciones de cadenas están declaradas en <string.h>. En la piscine se reescriben (con ft_ delante) para saber qué hacen por dentro, y luego se reúnen en la libft.

El comportamiento exacto está en el manual: man 3 strncpy, man strlcpy. El enunciado de ex10 solo dice «reproduce el comportamiento de strlcpy (man strlcpy)», así que el manual es la especificación. La sección 3 es la de funciones de biblioteca; sin número, man puede abrir antes un comando con el mismo nombre.

Tipos y lenguaje

unsigned int y mezclar con y sin signo

Un unsigned int no tiene signo: va de 0 a 4 294 967 295 en vez de -2 147 483 648 a 2 147 483 647. Al comparar un int con un unsigned int, C convierte el int a sin signo, y un negativo pasa a ser un número enorme: -1 < 1u da 0 (falso).

Por eso -Wextra avisa en cuanto se mezclan (comparison of integer expressions of different signedness), y con -Werror no compila. En ex01 y ex10 n y size son unsigned int, y los contadores también lo son.

Evaluación en cortocircuito (&& y ||)

a && b evalúa primero a, y si es falso ya no mira b: el resultado será falso igualmente. a || b se para si a es verdadero. El orden de las condiciones, por tanto, importa.

En ex01, while (i < n && src[i]) comprueba el límite antes de leer: con n = 0 no se toca src. En ex09, i != 0 && ft_is_alnum(str[i - 1]) evita leer str[-1], que está fuera de la cadena.

Cast (conversión de tipo)

Poner un tipo entre paréntesis delante de una expresión la convierte a ese tipo: (unsigned char)str[i] toma el mismo byte y lo interpreta sin signo. No cambia la memoria, solo cómo se lee el valor.

Con punteros cambia qué se ve en la dirección: en ex12, addr es un void *, y tratarlo como unsigned char * permite recorrerlo byte a byte.

void *: dirección sin tipo

Un puntero que guarda una dirección pero no dice qué hay allí. No se puede desreferenciar ni sumarle nada en C estándar, porque el compilador no sabe cuántos bytes ocupa lo apuntado; antes hay que convertirlo a un puntero con tipo.

Lo usan las funciones que trabajan con «memoria cualquiera»: malloc devuelve un void *, y ft_print_memory recibe uno porque tiene que poder volcar una cadena, un array de int o una struct.

Función static

Una función declarada static solo existe dentro de su archivo: otros archivos no la ven, y su nombre no choca con otra función igual en otro sitio.

En ex09, ft_is_alnum es static porque es una ayudante interna: si la Moulinette o la libft tienen otra ft_is_alnum, no hay conflicto al enlazar. ex12 hace lo mismo con sus tres ayudantes.

Estado y máquina de estados

Una máquina de estados es un programa que, además del dato que lee, recuerda en qué situación está, y actúa según las dos cosas. El estado es esa situación.

ex09 tiene dos estados, «al principio de una palabra» y «dentro de una palabra», y no los guarda en una variable: los deduce mirando el carácter anterior. Con la frase del enunciado, el código de la página da Salut, Comment Tu Vas ? 42mots Quarante-Deux; Cinquante+Et+Un, igual que el ejemplo.

La piscine

La Norma y norminette

Las reglas de estilo obligatorias en 42: funciones de 25 líneas como mucho, 5 funciones por archivo como mucho, declaraciones al principio y una por línea, nada de for, do…while, switch ni ternario. norminette las comprueba (y la cabecera de 42), aunque el enunciado avisa de que no lo ve todo.

Es la razón de que ex12 se parta en tres ayudantes: en una sola función no cabría en 25 líneas.

Moulinette

El corrector automático de 42. Compila cada ejercicio con cc -Wall -Wextra -Werror y su propio main, y compara los resultados con los de referencia. Un aviso del compilador, un archivo con otro nombre o un main olvidado en el archivo, y el ejercicio cuenta como suspendido.

ex00ft_strcpy

Prototipo: char *ft_strcpy(char *dest, char *src)

Copiar la cadena src dentro de dest, incluido el \0 final, y devolver dest.

char	*ft_strcpy(char *dest, char *src)
{
	int	i;

	i = 0;
	while (src[i])
	{
		dest[i] = src[i];
		i++;
	}
	dest[i] = '\0';
	return (dest);
}

El bucle avanza mientras src[i] no sea \0 (que en C vale 0, es decir falso). Al salir, src[i] es el terminador, así que hay que copiarlo a mano: sin la línea dest[i] = '\0' la copia no sería una cadena válida, solo una ristra de bytes sin final.

Concepto — el \0 no es opcional. En C una «string» no guarda su longitud en ningún sitio: es un puntero al primer carácter, y se sabe dónde acaba porque hay un byte 0. Todo el módulo depende de esta convención. Olvidar copiar el terminador es el bug clásico que hace que el siguiente printf imprima basura hasta topar con un 0 por casualidad.

ex01ft_strncpy

Prototipo: char *ft_strncpy(char *dest, char *src, unsigned int n)

Copiar como mucho n caracteres. Si src es más corto que n, el resto de dest se rellena con \0 hasta completar n.

char	*ft_strncpy(char *dest, char *src, unsigned int n)
{
	unsigned int	i;

	i = 0;
	while (i < n && src[i])
	{
		dest[i] = src[i];
		i++;
	}
	while (i < n)
	{
		dest[i] = '\0';
		i++;
	}
	return (dest);
}

Son dos bucles: el primero copia hasta que se acaba src o se llega a n; el segundo rellena con ceros lo que falte. La sutileza de strncpy —y la razón por la que es una función traicionera en la vida real— es que no garantiza terminador: si src tiene n caracteres o más, dest queda sin \0.

Concepto — el tipo importa. Aquí n es unsigned int, así que i también lo es. Mezclar int y unsigned en la condición i < n dispara avisos con -Wextra (y -Werror los convierte en error). Empezar a leer los prototipos y respetar los tipos exactos es parte del ejercicio.

ex02ft_str_is_alpha

Prototipo: int ft_str_is_alpha(char *str)Cadena vacía → 1

Devolver 1 si str contiene solo caracteres alfabéticos (y también para la cadena vacía), 0 si aparece cualquier otra cosa.

int	ft_str_is_alpha(char *str)
{
	int	i;

	i = 0;
	while (str[i])
	{
		if (str[i] < 'A' || (str[i] > 'Z' && str[i] < 'a') || str[i] > 'z')
			return (0);
		i++;
	}
	return (1);
}

La condición niega la pertenencia a los dos rangos de letras: A–Z (65–90) y a–z (97–122). Un carácter no es alfabético si está por debajo de 'A', en el hueco entre 'Z' y 'a' (donde viven [, \, ]...), o por encima de 'z'. La cadena vacía nunca entra al bucle, así que devuelve 1 «gratis».

Concepto — comparar caracteres es comparar números. Escribir str[i] >= 'a' funciona porque 'a' es 97 para el compilador. Este ejercicio (y los cinco siguientes) son la versión casera de las funciones isalpha, isdigit… de <ctype.h>: predicados que responden sí/no mirando en qué tramo de ASCII cae cada byte.

ex03ft_str_is_numeric

Prototipo: int ft_str_is_numeric(char *str)Cadena vacía → 1

Igual que el anterior pero con dígitos: 1 si todo son cifras 0–9.

int	ft_str_is_numeric(char *str)
{
	int	i;

	i = 0;
	while (str[i])
	{
		if (str[i] < '0' || str[i] > '9')
			return (0);
		i++;
	}
	return (1);
}

Los dígitos ocupan un tramo contiguo de ASCII ('0'=48 … '9'=57), así que basta un único rango. Ojo: comprueba caracteres dígito, no el valor numérico; el signo - o un punto decimal harían devolver 0.

Concepto — el carácter '0' no vale 0. Es 48. Esa distancia de 48 entre el dígito impreso y su valor es la que se usará en C04 para convertir texto a número (str[i] - '0'). Aquí solo se valida; allí se aprovechará.

ex04ft_str_is_lowercase

Prototipo: int ft_str_is_lowercase(char *str)Cadena vacía → 1

1 si todos los caracteres son minúsculas a–z.

int	ft_str_is_lowercase(char *str)
{
	int	i;

	i = 0;
	while (str[i])
	{
		if (str[i] < 'a' || str[i] > 'z')
			return (0);
		i++;
	}
	return (1);
}

Un solo rango, a–z. El patrón «recorrer y rechazar al primer fallo» se repite idéntico; cambia únicamente el intervalo.

Concepto — repetición deliberada. La piscina insiste en variaciones mínimas del mismo esqueleto a propósito: se busca que el bucle-con-guardia se vuelva un reflejo, no un problema a resolver cada vez.

ex05ft_str_is_uppercase

Prototipo: int ft_str_is_uppercase(char *str)Cadena vacía → 1

1 si todos los caracteres son mayúsculas A–Z.

int	ft_str_is_uppercase(char *str)
{
	int	i;

	i = 0;
	while (str[i])
	{
		if (str[i] < 'A' || str[i] > 'Z')
			return (0);
		i++;
	}
	return (1);
}

Simétrico a is_lowercase, con el rango de mayúsculas.

Concepto — mayúsculas antes que minúsculas. En ASCII las mayúsculas (65–90) van antes que las minúsculas (97–122). Por eso al ordenar cadenas byte a byte "Zoo" queda antes que "abeja": es la lógica que gobernará ft_strcmp en C03.

ex06ft_str_is_printable

Prototipo: int ft_str_is_printable(char *str)Cadena vacía → 1

1 si todos los caracteres son imprimibles.

int	ft_str_is_printable(char *str)
{
	int	i;

	i = 0;
	while (str[i])
	{
		if (str[i] < 32 || str[i] > 126)
			return (0);
		i++;
	}
	return (1);
}

El rango imprimible de ASCII va del espacio (32) a la tilde ~ (126). Por debajo de 32 están los caracteres de control (tabulador = 9, salto de línea = 10…), que existen pero no «se ven».

Concepto — hay bytes que no se ven. Esta frontera 32–126 es la clave de los dos últimos ejercicios del módulo: en ft_putstr_non_printable y ft_print_memory habrá que representar de otra forma los bytes que caen fuera de ella, porque enviarlos crudos a la terminal la ensuciaría o la haría pitar.

ex07ft_strupcase

Prototipo: char *ft_strupcase(char *str)Devuelve str

Pasar cada letra a mayúscula, modificando la cadena in situ.

char	*ft_strupcase(char *str)
{
	int	i;

	i = 0;
	while (str[i])
	{
		if (str[i] >= 'a' && str[i] <= 'z')
			str[i] = str[i] - 32;
		i++;
	}
	return (str);
}

La aritmética ASCII en acción: una minúscula está exactamente 32 posiciones por encima de su mayúscula ('a'−'A' = 97−65 = 32), así que restar 32 la convierte. Los caracteres que no son minúsculas se dejan intactos.

Concepto — modificar «en el sitio». La función no crea una copia: escribe sobre el mismo str que recibió. Esto solo es legal si quien llama pasó memoria escribible (un array, no un literal "...", que es de solo lectura). Entender la diferencia evita el segfault más habitual del módulo.

ex08ft_strlowcase

Prototipo: char *ft_strlowcase(char *str)Devuelve str

El inverso: cada letra a minúscula.

char	*ft_strlowcase(char *str)
{
	int	i;

	i = 0;
	while (str[i])
	{
		if (str[i] >= 'A' && str[i] <= 'Z')
			str[i] = str[i] + 32;
		i++;
	}
	return (str);
}

Ahora se suma 32 a las mayúsculas. Misma idea, signo opuesto.

Concepto — ¿por qué +32 y no una tabla?. Se podría mapear cada letra con una tabla de traducción, pero el +32 demuestra que la codificación ASCII no es arbitraria: mayúsculas y minúsculas se diseñaron separadas por una potencia de dos (32 = bit 5), justo para que cambiar la caja fuera una operación de un solo bit.

ex09ft_strcapitalize

Prototipo: char *ft_strcapitalize(char *str)Devuelve str

Poner en mayúscula la primera letra de cada palabra y el resto en minúscula. Una «palabra» es una secuencia de caracteres alfanuméricos.

static int	ft_is_alnum(char c)
{
	if (c >= '0' && c <= '9')
		return (1);
	if (c >= 'a' && c <= 'z')
		return (1);
	if (c >= 'A' && c <= 'Z')
		return (1);
	return (0);
}

char	*ft_strcapitalize(char *str)
{
	int	i;

	i = 0;
	while (str[i])
	{
		if (i != 0 && ft_is_alnum(str[i - 1]))
		{
			if (str[i] >= 'A' && str[i] <= 'Z')
				str[i] = str[i] + 32;
		}
		else if (str[i] >= 'a' && str[i] <= 'z')
			str[i] = str[i] - 32;
		i++;
	}
	return (str);
}

La clave es detectar el inicio de palabra: un carácter empieza palabra si es el primero de la cadena o si el anterior no es alfanumérico. En ese caso se fuerza a mayúscula; en cualquier otro, a minúscula. Con la entrada 42mots, el 4 abre palabra pero no es letra (queda igual), y la m ya no es inicio (el 2 anterior es alfanumérico), así que se queda minúscula: 42mots. El helper ft_is_alnum se declara static porque no forma parte de la entrega.

Concepto — el estado está en el vecino. Aquí ya no basta con mirar el carácter actual: la decisión depende del contexto (qué había justo antes). Es el primer ejercicio del módulo con una pizca de máquina de estados, y anticipa parsers más serios donde «dónde estoy» importa tanto como «qué leo».

ex10ft_strlcpy

Prototipo: unsigned int ft_strlcpy(char *dest, char *src, unsigned int size)

La copia «segura» de BSD: copia como mucho size − 1 caracteres, siempre pone \0 (si size > 0) y devuelve la longitud de src.

unsigned int	ft_strlcpy(char *dest, char *src, unsigned int size)
{
	unsigned int	i;
	unsigned int	len;

	len = 0;
	while (src[len])
		len++;
	i = 0;
	while (i + 1 < size && src[i])
	{
		dest[i] = src[i];
		i++;
	}
	if (size > 0)
		dest[i] = '\0';
	return (len);
}

Primero se mide src completo (ese es el valor a devolver, pase lo que pase con la copia). Luego se copia dejando siempre un hueco para el terminador: la guarda i + 1 < size reserva la última posición. Devolver la longitud real de src —aunque no quepa— es lo que permite a quien llama detectar que hubo truncamiento (retorno >= size).

Concepto — desbordamientos de búfer. strcpy no conoce el tamaño del destino: si src es más largo, escribe fuera y corrompe memoria (la base de incontables vulnerabilidades). strlcpy nació para eso: recibe size y nunca lo excede. Reimplementarla es tomar contacto con la seguridad de memoria, tema que atraviesa todo C.

ex11ft_putstr_non_printable

Prototipo: void ft_putstr_non_printable(char *str)Autorizada: write

Imprimir la cadena, pero mostrando los caracteres no imprimibles como \ seguido de su código hexadecimal en minúsculas y dos dígitos. Así, un salto de línea (0x0a) se ve como \0a.

void	ft_putstr_non_printable(char *str)
{
	char	*hex;
	int		i;

	hex = "0123456789abcdef";
	i = 0;
	while (str[i])
	{
		if (str[i] >= 32 && str[i] <= 126)
			write(1, &str[i], 1);
		else
		{
			write(1, "\\", 1);
			write(1, &hex[(unsigned char)str[i] / 16], 1);
			write(1, &hex[(unsigned char)str[i] % 16], 1);
		}
		i++;
	}
}

Para convertir un byte a hexadecimal se parte en dos «nibbles» de 4 bits: la cifra alta es byte / 16 y la baja byte % 16, y cada una indexa la tabla "0123456789abcdef". El (unsigned char) es crucial: sin él, un byte con el bit alto puesto (valor > 127) se interpretaría como char negativo y las divisiones darían índices negativos.

Concepto — hexadecimal como lenguaje de bytes. Un byte son 8 bits = dos dígitos hex exactos (00–ff). Por eso los volcados de memoria, los colores web y los hashes se escriben en hex: es la notación más compacta que mapea limpiamente cada mitad de un byte. Este ejercicio es el ensayo general del siguiente.

ex12ft_print_memory

Prototipo: void *ft_print_memory(void *addr, unsigned int size)Autorizada: write

Volcar una región de memoria en tres columnas, al estilo de un editor hexadecimal: la dirección en hex, el contenido en hex (agrupado de dos en dos bytes, relleno con espacios si la línea queda a medias) y el contenido como texto (los no imprimibles se sustituyen por .). Dieciséis bytes por línea; si size es 0 no se imprime nada. Devuelve addr.

$> ./ft_print_memory
000000010a161f40: 426f 6e6a 6f75 7220 6c65 7320 616d 696e Bonjour les amin
000000010a161f50: 6368 6573 090a 0963 0720 6573 7420 666f ches...c. est fo
...

La función se reparte en tres ayudantes static (dirección, columna hex, columna texto) más el bucle principal, que avanza de 16 en 16 bytes. El núcleo es la columna hex, que decide en cada posición si hay byte que imprimir o hay que rellenar con espacios para que la columna de texto quede siempre alineada:

static void	ft_hexline(unsigned char *p, unsigned int start, unsigned int size)
{
	char	*h;
	int		j;

	h = "0123456789abcdef";
	j = 0;
	while (j < 16)
	{
		if (start + j < size)
		{
			write(1, &h[p[start + j] / 16], 1);
			write(1, &h[p[start + j] % 16], 1);
		}
		else
			write(1, "  ", 2);
		if (j % 2 == 1)
			write(1, " ", 1);
		j++;
	}
}

El if (j % 2 == 1) mete un espacio tras cada dos bytes, y el else con dos espacios rellena las posiciones que ya no existen en la última línea: así, aunque la fila esté incompleta, la columna de texto arranca siempre en la misma columna. La dirección se imprime con un bucle que extrae los 16 dígitos hex de un unsigned long, y la columna de texto reusa la frontera 32–126 de ft_str_is_printable.

Concepto — la memoria es un array de bytes, y punto. Un void * es «una dirección, sin tipo». Al castearlo a unsigned char * le decimos al compilador «trátalo como bytes crudos» y podemos recorrerlo como cualquier array. Esto es literalmente lo que hacen gdb, xxd o un depurador: no hay variables ni tipos ahí abajo, solo bytes en direcciones consecutivas. Ver una struct o un int «desnudos» en hex es el momento en que la memoria deja de ser abstracta.

?Preguntas probables de la evaluación

Lo que es fácil que pregunte quien te evalúe en C02, con una respuesta corta y el enlace a donde está explicado. Están agrupadas en: copias, caracteres, y pruebas y entrega. Antes de mirar la respuesta, intenta contestar tú.

Copias

En ft_strcpy, ¿por qué copias el '\0' fuera del bucle?

Porque el bucle se para justo al llegar a él: while (src[i]) es falso cuando src[i] es 0. Sin dest[i] = '\0', dest no acabaría y quien la leyera seguiría hasta encontrar un 0 por casualidad. → terminador, ex00

¿ft_strncpy deja siempre una cadena terminada?

No, y la de verdad tampoco. Si src tiene n caracteres o más, copia n y no pone terminador: ft_strncpy(e, "Hola mundo", 4) deja Hola sin 0 detrás. Si src es más corto, rellena con ceros hasta n. → ex01

¿Qué devuelve ft_strlcpy y para qué sirve?

La longitud de src, haya cabido o no. Si es >= size, la copia se ha cortado. ft_strlcpy(d, "Hola mundo", 6) deja "Hola " y devuelve 10. → truncar, ex10

¿Y si size es 0?

No se escribe nada en dest, ni siquiera el terminador (no hay sitio), y se devuelve la longitud de src. La guarda i + 1 < size impide copiar y el if (size > 0) impide escribir el 0. → ex10

¿Importa el orden en i < n && src[i]?

Sí. && se para en la primera condición falsa, así que comprobar el límite primero evita leer src[n], que puede no existir. Con n = 0 no se lee src en absoluto. → cortocircuito

Caracteres

¿Por qué ft_str_is_alpha("") devuelve 1?

Porque lo pide el enunciado, y tiene sentido: «todos los caracteres son letras» es cierto si no hay ninguno que no lo sea. En el código sale sin un caso especial: no se entra en el bucle y se llega al return (1). → verdad vacía

¿Por qué sumas o restas 32?

Porque en ASCII cada minúscula está 32 posiciones por encima de su mayúscula ('a' 97, 'A' 65). Antes se comprueba que es una letra; si no, se deja como está. Escribir 'a' - 'A' en vez de 32 es lo mismo. → distancia de 32, ex07

¿Qué hace tu ft_strcapitalize con 42mots y con quarante-deux?

Empieza palabra el carácter cuyo anterior no es alfanumérico. 42mots se queda igual: la m va detrás de un 2. quarante-deux da Quarante-Deux, porque el guion corta la palabra. Y lo que no empieza palabra se pasa a minúscula: HOLA da Hola. → ex09

¿Para qué sirve el (unsigned char) de ft_putstr_non_printable?

En los PC de 42 char tiene signo, y un byte por encima de 127 es negativo: la é de café son los bytes 0xc3 y 0xa9, que como char valen -61 y -87. Sin el cast, / 16 y % 16 darían índices negativos en la tabla hex. Con él sale caf\c3\a9. → char con signo, ex11

En ft_print_memory, ¿por qué rellenas con espacios la última línea?

Para que la columna de texto empiece siempre en la misma columna. Cada byte que falta ocupa dos espacios, y se sigue metiendo el espacio cada dos bytes. → ex12

Pruebas y entrega

Tu main de prueba de ft_strupcase da segfault. ¿Por qué?

Casi seguro le estás pasando un literal: ft_strupcase("hola") o char *s = "hola". Los literales son de solo lectura. Hay que usar un array, char s[] = "hola";. → literal

¿Por qué ft_is_alnum es static? ¿Puedes añadir funciones?

Sí, se pueden añadir funciones al archivo, siempre que cumplan la Norma. Se declaran static para que no salgan del archivo: si la Moulinette enlaza con otra función del mismo nombre, no hay choque. → static, la Norma