Reimplementar printf con nueve conversiones (cspdiuxX%) y
empaquetarla en libftprintf.a. El proyecto parece de formato de texto, pero lo que
enseña de verdad es cómo una función de C puede recibir un número de argumentos que no conoce
— y cómo construir una librería encima de otra.
write y funciones hechas a mano: ft_putnbr, ft_putstr
(de ahí el subtítulo del enunciado: «porque ft_putnbr() y ft_putstr() no son suficientes»).
printf es la función que todo programador de C usa a diario y casi nadie ha mirado
por dentro. El enunciado prohíbe gestionar el buffer interno del printf original (cada carácter
va directo con write) y solo autoriza malloc, free,
write y la familia va_*; la libft sí está permitida. El resultado se
compara byte a byte con el printf de verdad, valor de retorno incluido. Y una vez aprobado,
ft_printf entra en tu caja de herramientas para todos los proyectos siguientes.La página usa palabras que vienen de cómo C pasa los argumentos, de cómo guarda los números y de cómo se monta una librería. Aquí está cada una explicada desde cero y con un ejemplo sacado del propio ft_printf. 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.
Una función que acepta un número variable de argumentos. Se declara con ... al
final de la lista de parámetros, detrás de al menos uno con nombre. Ni la función ni el compilador
saben cuántos argumentos llegarán ni de qué tipo: eso lo tiene que deducir la propia función a
partir de los que sí tienen nombre.
En ft_printf, int ft_printf(const char *format, ...). En
ft_printf("%d|%c|%s", INT_MIN, 'A', NULL) llegan tres argumentos sin nombre, y es el
formato, con sus tres conversiones, el que dice que hay tres y cómo leer cada uno. Imprime
-2147483648|A|(null) y devuelve 20.
De dónde viene: <stdarg.h> llegó con el estándar ANSI C de 1989.
Antes cada sistema tenía su versión, la más extendida <varargs.h>, que no
exigía ningún parámetro con nombre.
va_list, va_start, va_arg y va_endLas piezas de <stdarg.h> para recorrer los argumentos sin nombre.
va_list es el tipo del «cursor»; va_start(ap, ultimo) lo coloca detrás
del último parámetro con nombre; va_arg(ap, tipo) devuelve el siguiente argumento
leído como tipo y avanza; va_end(ap) cierra el recorrido. Hay una quinta,
va_copy, que duplica el cursor para recorrer la lista dos veces.
ft_printf usa las cuatro primeras: va_start(ap, format) al empezar, un
va_arg en cada rama de ft_conv y va_end en las dos salidas
(la normal y la de error). va_copy está autorizada pero no hace falta, porque los
argumentos se leen una sola vez.
Cuando un argumento cae en la parte ... de una llamada, C lo convierte antes de
pasarlo: char y short se convierten en int, y
float en double. La función nunca recibe un char, así que
pedirlo con va_arg(ap, char) es incorrecto; gcc incluso avisa de que «char
is promoted to int».
Por eso %c se lee con va_arg(*ap, int) y
ft_print_char recibe un int que luego convierte a unsigned
char. Con ft_printf("%c", 'B' + 256) llega el int 322, la
conversión se queda con el byte de abajo (322 − 256 = 66) y sale B.
La cadena de formato es el primer argumento de printf: texto que se copia tal cual con
conversiones intercaladas, cada una un % seguido de una letra que dice
qué tipo de argumento viene y cómo escribirlo. En el printf completo, entre el % y la
letra puede haber más cosas: flags (-0#+ ), anchura (%5d), precisión
(%.3s) y tamaño (%ld).
ft_printf solo entiende la letra: las nueve de cspdiuxX%. %% es la
única que no consume argumento: ft_printf("%d%%", 42) escribe 42% y
devuelve 3, igual que printf.
Un trozo de código que, según un valor, decide a qué función llamar. Se puede escribir con una
cadena de if, con un switch o con una tabla de dispatch: un
array de punteros a función indexado por ese valor.
ft_conv es un despachador con if (la Norma prohíbe
switch): mira la letra, saca el argumento con el tipo correcto y llama a la función
que lo imprime. Añadir una conversión es añadir un if y una función.
Situaciones en las que el estándar de C no dice qué debe pasar: el programa puede dar el resultado esperado, otro distinto o colgarse, y puede cambiar con el compilador o las optimizaciones. No es un error que se detecte al compilar.
Con printf hay muchos: una conversión desconocida (%k), un % suelto al
final, pasar un double a %d o NULL a %s.
Cada libc hace lo que quiere y ft_printf también: ft_printf("abc%") escribe
abc% y devuelve 4, mientras que el printf de glibc escribe abc y devuelve
−1. El tester del repo no prueba ninguno de estos casos.
Escribir un número en base b es expresarlo con b símbolos, donde cada posición vale b veces la
de su derecha. En base 10, 255 es 2·100 + 5·10 + 5. En base 16, 255 = 15·16 + 15, y como el 15
se escribe f, sale ff.
Para sacar las cifras se divide por la base una y otra vez: el resto (n % b) es
la cifra de la derecha y el cociente (n / b) es lo que queda por escribir.
ft_itoa_base recibe la base como una cadena de símbolos, así que la misma función
sirve para "0123456789", "0123456789abcdef" y
"0123456789ABCDEF".
La base 16, con las cifras 0–9 y a–f (de
10 a 15). Se usa tanto porque cada cifra hexadecimal equivale exactamente a 4 bits: un byte son
dos cifras y un int de 32 bits, ocho. El prefijo 0x es como C marca un
número escrito en hexadecimal.
En ft_printf, %x de −1 da ffffffff: los 32 bits a 1, ocho efes.
%X de 255 da FF, y %p de (void *)255,
0xff.
Un int y un unsigned int ocupan los mismos 32 bits, pero se leen
distinto. El unsigned va de 0 a 4 294 967 295. El int usa el
complemento a dos: el bit de más peso cuenta como negativo, y el rango queda de
−2 147 483 648 (INT_MIN) a 2 147 483 647 (INT_MAX).
Los mismos bits dan cosas distintas según la conversión: −1 con %d sale
-1, con %u sale 4294967295 y con %x,
ffffffff. Y INT_MIN no tiene opuesto dentro del int
(2 147 483 648 no cabe), por eso la ft_itoa de esta libft no hace nunca
-n: escribe cada cifra como -(n % 10).
C no fija cuántos bytes ocupa cada tipo; solo pone mínimos. En Linux de 64 bits (el modelo
llamado LP64) son: int y unsigned int, 4 bytes; long,
unsigned long y cualquier puntero, 8. En Windows de 64 bits long se
queda en 4.
Medido con sizeof en el ordenador donde se probó este ft_printf: 4, 4, 8 y 8. Es
la razón de que ft_print_hex reciba un unsigned long: una dirección de 8
bytes no cabe en un unsigned int.
Pasar un valor de un tipo a otro. Puede ser explícita, escribiendo el tipo entre
paréntesis ((unsigned char)c), o implícita, cuando C la hace solo, por
ejemplo al pasar un argumento a una función que espera otro tipo.
ft_printf tiene de las dos. Explícitas: (unsigned char)c en
ft_print_char y (unsigned long)p en ft_print_ptr.
Implícita: en ft_print_hex(va_arg(*ap, unsigned int), 0) el unsigned
int se amplía a unsigned long rellenando con ceros por la izquierda, sin
cambiar el valor.
Una función es recursiva si se llama a sí misma con un problema más pequeño, hasta llegar a un caso base que se resuelve sin volver a llamarse. Cada llamada pendiente ocupa sitio en la pila de llamadas hasta que vuelve.
ft_itoa_base lo es. Con 255 en base 16: la primera llamada (d = 0) ve que
255 / 16 = 15 no es 0 y se llama con 15 (d = 1). Ahí 15 / 16 = 0: es el caso base, que ya sabe
que hay d + 1 = 2 cifras, reserva 3 bytes y los deja en "00". Escribe su cifra,
f, en la posición 0, vuelve, y la primera escribe la suya (255 % 16 = 15, otra
f) en la posición 1: "ff".
Un puntero guarda una dirección: el número de la posición de memoria donde está un
dato. Imprimirlo con %p es escribir ese número en hexadecimal con
0x delante.
La dirección de una variable local sale algo como 0x7ffcb2d749d0, y cambia en cada
ejecución porque Linux coloca la pila en un sitio distinto cada vez (ASLR). Para ver un valor fijo
se puede convertir un número en puntero: ft_printf("%p", (void *)255) da
0xff.
NULLEl puntero que no apunta a nada; vale 0. Leer a través de él es comportamiento indefinido y casi siempre un segfault.
ft_printf no lo lee nunca: lo comprueba antes. %s con NULL imprime
(null) y %p con NULL imprime (nil), que es lo
que hace glibc. El printf de macOS escribe 0x0 para el puntero nulo.
malloc, free y el heapmalloc(n) reserva n bytes en el heap, una zona de memoria que no se
libera sola al salir de la función, y devuelve su dirección, o NULL si no hay sitio.
free devuelve esa memoria. Cada malloc necesita exactamente un
free.
En ft_printf cada número impreso cuesta un malloc: ft_itoa y
ft_itoa_base devuelven la cadena reservada y ft_print_free la imprime y la
libera. Es el único free del proyecto.
Una fuga (leak) es memoria reservada que ya no se puede liberar porque no queda ningún
puntero hacia ella. Valgrind ejecuta el programa vigilando cada malloc y cada
free y al final dice lo que quedó sin liberar.
Un programa que llama a ft_printf con %d, %u, %x,
%p y %s termina en valgrind con «in use at exit: 0 bytes in 0 blocks».
El tester del repo además hace fallar el malloc número k de una llamada, para cada k,
y comprueba que no revienta ni pierde memoria.
write, descriptores y stdoutwrite(fd, buf, n) manda n bytes al descriptor fd y devuelve cuántos
escribió, o −1 si falla. Devuelve un ssize_t, un entero con signo del tamaño de
size_t, precisamente para poder devolver −1. El descriptor 1 es la salida estándar
(stdout), la terminal salvo que se redirija.
ft_printf escribe todo con write(1, …) y devuelve −1 en cuanto uno falla. Se
puede provocar cerrando stdout al lanzar el programa: con ./a.out >&-, un
ft_printf("hola %d\n", 42) que normalmente devuelve 8 devuelve −1.
Un buffer es una zona de memoria donde se acumulan datos antes de mandarlos de golpe. El printf
de la libc no llama a write en cada carácter: guarda la salida y la vacía al llegar
un '\n' (si stdout es una terminal), cuando se llena (si es un fichero o una tubería)
o al terminar el programa. Así hace muchas menos llamadas al sistema.
El enunciado prohíbe implementarlo, y ft_printf escribe cada trozo en el momento. Una
consecuencia práctica: si en un mismo programa se mezclan printf y
ft_printf, la salida de printf puede aparecer más tarde de lo esperado si
no se hace fflush(stdout).
El estándar de C dice qué debe hacer printf, pero quien lo programa de verdad es cada biblioteca de C (libc). En Linux es casi siempre glibc, la de GNU; macOS usa la suya, que viene de BSD. En lo que el estándar deja abierto, cada una decide.
ft_printf imita a glibc, que es lo que comparan los testers en Linux: (null) para
%s de NULL y (nil) para %p de
NULL. El tester del repo compara cada caso con el snprintf de glibc.
Compilar con cc -c convierte cada .c en un .o: código
máquina con una lista de símbolos, los que define (sus funciones) y los que usa sin
definir. El enlazador junta los .o y las librerías y une cada uso con su
definición; si falta una, da «undefined reference».
nm libftprintf.a enseña esa lista. Los símbolos marcados U (usados y
no definidos en ese objeto) que vienen de fuera de la librería son malloc,
free y write, más __stack_chk_fail, que no lo llama el
código sino la protección de pila que añade el compilador.
arUna librería estática (.a) es un archivo que contiene varios .o,
como un zip sin comprimir. Al enlazar, el enlazador saca de ella solo los objetos que el programa
necesita y los copia dentro del ejecutable. ar es la herramienta que crea y modifica
esos archivos.
ar rcs: r mete los .o (sustituyendo los que tengan el
mismo nombre), c crea el archivo sin avisar si no existe y s escribe el
índice de símbolos. El Makefile copia libft.a como libftprintf.a y le
añade los cuatro objetos de ft_printf.
Una regla de Makefile dice objetivo: dependencias y, debajo, con un tabulador
delante, la receta: los comandos que lo construyen. make rehace el objetivo solo si
no existe o si alguna dependencia es más nueva. En las reglas de patrón como
%.o: %.c, $< es la primera dependencia y $@ el
objetivo.
Aquí cada .o depende de su .c, de ft_printf.h y de
libft/libft.h, así que tocar un header recompila los objetos que lo usan.
.PHONYMarca objetivos que no son ficheros, como all o clean. Sin ella, si
alguien crea un fichero llamado clean, make clean diría que ya está
hecho y no borraría nada.
El Makefile marca también libft: es un objetivo falso que siempre ejecuta
$(MAKE) -C libft, y es el Makefile de la libft el que decide si tiene algo que
recompilar.
Volver a enlazar (o a reconstruir la librería) cuando no ha cambiado nada. En 42 se comprueba
lanzando make dos veces: la segunda no debe recompilar ni rehacer el
.a.
Con este Makefile la segunda vez solo entra en libft/, que contesta «Nothing to
be done for 'all'», y libftprintf.a no se toca. El tester del repo lo comprueba
(«make otra vez no recompila nada»).
La Norma es el estilo obligatorio del C de 42: como mucho 25 líneas por función, 5 funciones
por fichero, 4 parámetros y 5 variables por función, sin for, switch ni
do while, tabuladores para sangrar y la cabecera de 42 en cada fichero.
norminette es el programa que la comprueba.
En ft_printf pasan los 50 ficheros, libft incluida. La Norma explica parte del diseño: el
reparto en cuatro .c y que ft_conv sea una cadena de
if.
El prototipo lo fija el enunciado: int ft_printf(char const *, ...);. Los tres
puntos dicen «después de format vienen cuantos argumentos quieras, del tipo que
quieras». El bucle principal del usuario:
int ft_printf(const char *format, ...)
{
va_list ap;
int count;
int ret;
if (!format)
return (-1);
va_start(ap, format);
count = 0;
while (*format)
{
if (*format == '%' && *(format + 1))
ret = ft_conv(*(++format), &ap);
else
ret = ft_print_char(*format);
if (ret < 0)
{
va_end(ap);
return (-1);
}
count += ret;
format++;
}
va_end(ap);
return (count);
}
Las cuatro piezas de <stdarg.h>:
va_list ap — el «cursor» sobre los argumentos sin nombre.va_start(ap, format) — lo coloca justo después del último parámetro con
nombre. Por eso una función variádica necesita al menos uno.va_arg(ap, tipo) — devuelve el siguiente argumento interpretándolo como
tipo y avanza. Nadie comprueba que el tipo sea el correcto: lo dice el formato.va_end(ap) — cierra el recorrido. Aquí se llama en las dos salidas: la normal
y la de error.Un detalle fino: ap se pasa a ft_conv como &ap
(un va_list *). Así cada va_arg que hace la función auxiliar avanza el
mismo cursor que ve ft_printf. Pasar el va_list por valor y seguir
usándolo después en la función que llama no es portable.
%d y pasas un double, va_arg leerá basura sin
quejarse — por eso el compilador avisa con -Wformat en el printf real, pero
no con el tuyo (salvo que lo marques con __attribute__((format))). También aparece la promoción de argumentos por defecto: en la parte
variádica de una llamada, todo char y short se convierte en
int, y todo float en double. Es la razón de que
%c se lea con va_arg(*ap, int) y no con char: el
char nunca llega como char.static int ft_conv(char c, va_list *ap)
{
if (c == 'c')
return (ft_print_char(va_arg(*ap, int)));
if (c == 's')
return (ft_print_str(va_arg(*ap, char *)));
if (c == 'p')
return (ft_print_ptr(va_arg(*ap, void *)));
if (c == 'd' || c == 'i')
return (ft_print_nbr(va_arg(*ap, int)));
if (c == 'u')
return (ft_print_unsigned(va_arg(*ap, unsigned int)));
if (c == 'x')
return (ft_print_hex(va_arg(*ap, unsigned int), 0));
if (c == 'X')
return (ft_print_hex(va_arg(*ap, unsigned int), 1));
if (c == '%')
return (ft_print_char('%'));
return (-1);
}
Cada letra decide dos cosas a la vez: con qué tipo se saca el argumento y qué función lo imprime.
| Conversión | va_arg | Imprime |
|---|---|---|
%c | int | ft_print_char |
%s | char * | ft_print_str |
%p | void * | ft_print_ptr |
%d %i | int | ft_print_nbr |
%u | unsigned int | ft_print_unsigned |
%x %X | unsigned int | ft_print_hex (minúsculas / mayúsculas) |
%% | — (no consume argumento) | ft_print_char('%') |
Fíjate en que %% no llama a va_arg: si lo hiciera, desplazaría todos
los argumentos siguientes una posición.
Ojo con dos casos fuera del enunciado. Una letra desconocida (%k) hace que
ft_conv devuelva -1 y ft_printf se corta ahí devolviendo
-1, con lo anterior ya escrito. Y un % suelto al final de la cadena no
entra en la rama de conversión (por la comprobación *(format + 1)) y se imprime tal
cual: ft_printf("abc%") escribe abc% y devuelve 4, mientras que glibc
devuelve -1. Las dos situaciones son comportamiento indefinido en el estándar, así
que no hay una respuesta «correcta», pero conviene saber qué hace tu versión por si sale en la
evaluación.
printf devuelve el número de caracteres escritos, o un negativo si algo falla.
El usuario lo resuelve con una regla única para todas las funciones de impresión: cada una
devuelve cuántos caracteres ha escrito, o -1 si write ha fallado.
El bucle solo suma:
if (ret < 0)
{
va_end(ap);
return (-1);
}
count += ret;
Por eso ft_print_char y ft_print_str devuelven directamente lo que
devuelve write (un ssize_t), y las funciones de números devuelven la
longitud de la cadena que imprimen. %p suma a mano los dos caracteres de
0x (se ve abajo).
write puede fallar (por ejemplo, si cierras stdout
con ./a.out >&-) y un printf serio tiene que enterarse. Definir un contrato
común para todas las funciones auxiliares es lo que hace que el conteo quede en dos
líneas.ssize_t ft_print_char(int c)
{
unsigned char chr;
chr = (unsigned char) c;
return (write(1, &chr, 1));
}
ssize_t ft_print_str(char *str)
{
if (!str)
str = "(null)";
return (write(1, str, ft_strlen(str)));
}
ft_print_char recibe un int (por la promoción) y lo convierte a
unsigned char antes de escribir, que es exactamente lo que hace el printf real con
%c. La cadena se escribe de una sola vez con su longitud, no carácter a carácter.
printf("%s", NULL) es comportamiento indefinido según el estándar, pero glibc
imprime (null) y los testers lo comparan; el usuario reproduce ese resultado.
unsigned char no es decorativa: así se pasa a
write exactamente un byte con el valor que pidió quien llamó.int ft_print_nbr(int n)
{
return (ft_print_free(ft_itoa(n)));
}
int ft_print_unsigned(unsigned int n)
{
return (ft_print_free(ft_itoa_base(n, "0123456789", 10, 0)));
}
En vez de reescribir putnbr, el usuario reutiliza su libft: convierte el número
en una cadena reservada con malloc y la imprime. Para no repetir el
«imprimir y liberar» en cada sitio, todo pasa por un único helper:
int ft_print_free(char *str)
{
int ret;
if (!str)
return (-1);
ret = ft_print_str(str);
free(str);
return (ret);
}
Si malloc falló, la cadena es NULL y se devuelve -1.
Si no, se imprime y se libera siempre, haya ido bien el write o no. Es el
único free del proyecto, y por eso no hay forma de dejar un leak por un camino de
error.
%d e %i usan ft_itoa, que ya gestiona el signo y
INT_MIN. %u usa ft_itoa_base, una función de la piscine
(C07) adaptada a unsigned long y añadida a la libft de este repo:
char *ft_itoa_base(unsigned long n, char *base, int b, int d)
{
char *r;
int dd;
if (n / b != 0)
r = ft_itoa_base(n / b, base, b, d + 1);
else
{
r = (char *)malloc(sizeof(char) * (d + 2));
r = ft_char_init(r, d + 1);
}
if (!r)
return (NULL);
dd = ft_strlen(r);
r[dd - 1 - d] = base[n % b];
return (r);
}
El parámetro d cuenta la profundidad. La llamada más profunda (la de la cifra más
significativa) ya sabe cuántas cifras hay en total, d + 1, y reserva la cadena una
sola vez, rellena de '0' por ft_char_init. Luego, a la vuelta de la
recursión, cada nivel escribe su cifra (n % b) en la posición que le toca, contando
desde el final.
malloc y alguien tiene que liberarlo; centralizar el
free en un solo punto es la manera de no tener que pensar en ello en cada
conversión. Y repasa la descomposición en cifras de C 00: la recursión vuelve a invertir el
orden «de la última cifra a la primera» gratis, esta vez en cualquier base.int ft_print_hex(unsigned long n, int upper)
{
char *hex;
if (upper)
hex = "0123456789ABCDEF";
else
hex = "0123456789abcdef";
return (ft_print_free(ft_itoa_base(n, hex, 16, 0)));
}
/* "0x" + la direccion en hex; NULL sale "(nil)", como en glibc. */
int ft_print_ptr(void *p)
{
int ret;
if (!p)
return (ft_print_str("(nil)"));
if (ft_print_str("0x") < 0)
return (-1);
ret = ft_print_hex((unsigned long)p, 0);
if (ret < 0)
return (-1);
return (ret + 2);
}
La base no es un número sino una cadena de símbolos: la cifra k se
escribe como base[k]. Cambiar de minúsculas a mayúsculas es cambiar de cadena; la
misma ft_itoa_base sirve para base 10 y base 16.
ft_print_hex recibe un unsigned long aunque %x saque un
unsigned int: es para que %p pueda reutilizarla. En Linux de 64 bits
una dirección ocupa 8 bytes y no cabe en un unsigned int de 4; el
unsigned int de %x se amplía sin pérdida al pasar. Así, con
-1 sale ffffffff (el int reinterpretado como
unsigned int), no ffffffffffffffff.
Para el puntero NULL el usuario imprime (nil), que es lo que hace
glibc. Ojo: es un comportamiento propio de glibc; el printf de macOS imprime
0x0. Si el corrector prueba en otro sistema, el resultado esperado cambia.
int, unsigned int y unsigned long no son
intercambiables, y elegir el tipo del parámetro (aquí, el más ancho) es lo que permite que una
sola función sirva para dos conversiones. Y que «hexadecimal» no es nada especial: cualquier
base es una tabla de símbolos más divisiones sucesivas.NAME = libftprintf.a
LIBFT_DIR = libft
LIBFT = $(LIBFT_DIR)/libft.a
SRCS = ft_printf.c ft_print_chars.c ft_print_nbrs.c ft_print_hex.c
OBJS = $(SRCS:.c=.o)
all: libft $(NAME)
libft:
$(MAKE) -C $(LIBFT_DIR)
$(LIBFT): libft
$(NAME): $(OBJS) $(LIBFT)
cp $(LIBFT) $(NAME)
ar rcs $(NAME) $(OBJS)
%.o: %.c ft_printf.h $(LIBFT_DIR)/libft.h
$(CC) $(CFLAGS) -c $< -o $@
El enunciado pide que, si usas la libft, la copies en un directorio libft/ con
su propio Makefile, y que el Makefile del proyecto la compile primero. Eso hace la regla falsa
(.PHONY) libft: delega con $(MAKE) -C libft, y es la libft
la que decide si tiene algo que recompilar.
El truco está en la regla de $(NAME): copia libft.a con el nombre
libftprintf.a y luego ar rcs le añade los objetos de
ft_printf. Como un .a no es más que un archivo de .o, el resultado es
una sola librería con todo dentro, y quien la use enlaza solo con -lftprintf. Sin
esto, ft_print_str llamaría a un ft_strlen que no está en
libftprintf.a y el enlazado fallaría.
Los .o dependen también de los dos headers, así que tocar
ft_printf.h o libft.h recompila lo necesario. Ejecutar
make dos veces seguidas solo vuelve a entrar en libft/ (que responde
«Nothing to be done») y no relinka. clean y fclean también delegan en
la libft.
make -C), cada uno responsable de lo suyo.
Es la primera vez que la libft deja de ser un proyecto aislado y pasa a ser una pieza que otro
proyecto consume, que es para lo que existe.Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a la sección donde está explicado a fondo. Están agrupadas en: argumentos variables, casos límite, memoria y errores, y Makefile y Norma. Antes de mirar la respuesta, intenta contestar tú.
ft_printf cuántos argumentos le pasan?No lo sabe: lo dice el formato. Cada conversión, menos %%, consume un argumento
con va_arg. Si el formato pide más de los que se pasaron, se lee basura, y nadie lo
comprueba. → va_*
%c se lee con va_arg(*ap, int) y no con char?Por la promoción por defecto: en la parte ... de una llamada, un
char llega convertido en int. Pedir un char sería leer un
tipo que no está ahí. Luego ft_print_char lo pasa a unsigned char y
escribe ese byte. → va_*, %c %s %%
&ap a ft_conv en vez de ap?Para que el va_arg que hace ft_conv avance el mismo cursor que usa
ft_printf. Si se pasa por valor, el estándar no garantiza en qué estado queda
ap en la función que llama después de que la otra lo use. → va_*
ft_print_hex recibe un unsigned long si %x es unsigned int?Para reutilizarla en %p: una dirección ocupa 8 bytes en Linux de 64 bits y no
cabe en un unsigned int de 4. El unsigned int de %x se
amplía sin cambiar de valor, así que %x de −1 sigue dando ffffffff.
→ %x %X %p
%s y %p de NULL?(null) y (nil), como glibc. El estándar no lo define: en macOS el
puntero nulo sale 0x0, así que si el evaluador compara en un Mac verá otra cosa.
→ %c %s %%, %x %X %p
INT_MIN, y con −1 en %u y %x?-2147483648, 4294967295 y ffffffff. Con
INT_MIN el peligro es hacer -n, que desborda; la ft_itoa de
esta libft no lo hace nunca: escribe cada cifra como -(n % 10).
→ %d %i %u
ft_printf("abc%") o con %k?Son comportamiento indefinido en printf. Con "abc%" se imprime
abc% y se devuelve 4 (glibc escribe abc y devuelve −1). Con
%k, ft_conv devuelve −1 y ft_printf se para ahí devolviendo
−1, con lo anterior ya escrito. → despacho
%-5d?No: no hay regla bonus ni flags. El - se toma como una conversión
desconocida: ft_printf("[%-5d]", 42) escribe [ y devuelve −1. El tester
del repo pasa los 113 casos del bonus para información y fallan todos, sin contar como fallo.
→ despacho
ft_printf y cuándo devuelve −1?El número de caracteres escritos. −1 si el formato es NULL, si un
write falla (por ejemplo con stdout cerrado, ./a.out >&-), si falla
un malloc al convertir un número o con una conversión desconocida. Cada función de
impresión devuelve lo que escribió o −1, y el bucle solo suma. → return
malloc?No. Cada número se convierte en una cadena reservada y ft_print_free la libera
siempre después de imprimirla, haya ido bien el write o no. Si el
malloc falla, la cadena es NULL, no se imprime nada y se devuelve −1.
El tester hace fallar un malloc en cada punto posible (6 casos, todos OK) y valgrind
termina con 0 bytes en uso. → %d %i %u
Porque el enunciado prohíbe gestionar el buffer del printf original: cada trozo va directo con
write. Es más lento (más llamadas al sistema) pero más simple, y la salida nunca se
queda retenida. → buffer de salida
libftprintf.a?La regla de $(NAME) copia libft/libft.a con el nombre
libftprintf.a y luego ar rcs le añade los objetos de ft_printf. Queda
una sola librería con todo, y quien la use solo enlaza con -lftprintf. Sin eso,
ft_strlen o ft_itoa faltarían al enlazar. → make
make dos veces.No. La segunda vez solo se ejecuta make -C libft (la regla libft es
.PHONY), que responde «Nothing to be done for 'all'», y la librería no se rehace.
Tocar ft_printf.h sí recompila los objetos, porque son dependencias de la regla
%.o. → make
Un if más en ft_conv, con su va_arg del tipo correcto, y
una función de impresión que devuelva lo escrito o −1. El bucle de ft_printf y el
cálculo del retorno no cambian. Ojo con la Norma: ft_conv no puede pasar de 25
líneas. → despacho