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.
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.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.
char: un número pequeñoUn 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.
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é | Caracteres | Códigos |
|---|---|---|
| Control | tabulador, 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'.
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 .).
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 charSi 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".
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.
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.
'\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.
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.
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).
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.
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 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.
manLa 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.
unsigned int y mezclar con y sin signoUn 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.
&& 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.
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 tipoUn 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.
staticUna 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.
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.
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.
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.
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.
\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.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.
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.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».
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.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.
'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á.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.
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.
"Zoo" queda antes que "abeja": es la lógica que gobernará
ft_strcmp en C03.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».
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.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.
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.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.
+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.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.
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).
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.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.
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.
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.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ú.
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
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
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
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
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
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
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
(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
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
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