Cursus — ft_printf

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.

Por qué printf — En la piscine todo salía por pantalla con 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.

GGlosario de teoría

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.

Argumentos y formato

Función variádica

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_end

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

Promoción de argumentos por defecto

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.

Cadena de formato y conversión

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.

Despachador

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.

Comportamiento indefinido

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.

Números y bases

Base de numeración

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

Hexadecimal

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.

Con signo y sin signo

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

Tamaño de los tipos

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.

Conversión de tipo (cast)

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.

Recursión

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

Memoria y salida

Puntero y dirección

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.

NULL

El 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 heap

malloc(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.

Fuga de memoria y valgrind

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 stdout

write(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.

Buffer de salida

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

glibc y «la implementación»

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.

Compilación y librerías

Fichero objeto, símbolos y enlazado

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.

Librería estática y ar

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

Makefile: objetivo, dependencias y receta

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.

.PHONY

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

La Norma y norminette

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.

va_*Funciones variádicas

Entrega: ft_printf.c, ft_printf.hAutorizado: va_start, va_arg, va_copy, va_end, write

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>:

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.

Qué te obliga a aprender — Que en C los argumentos no llevan etiqueta de tipo: en la llamada solo viajan bytes, y es el formato el que dice cómo leerlos. Si escribes %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.

cspdiuxX%El despacho por conversión

Entrega: ft_printf.cAutorizado: va_arg
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ónva_argImprime
%cintft_print_char
%schar *ft_print_str
%pvoid *ft_print_ptr
%d %iintft_print_nbr
%uunsigned intft_print_unsigned
%x %Xunsigned intft_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.

Qué te obliga a aprender — A separar el análisis del formato de la impresión: el bucle principal no sabe nada de números ni de cadenas, solo reparte trabajo. Es la «estructura extensible» que pide el enunciado: añadir una conversión es añadir una línea aquí y una función. También deja claro que el tipo de cada argumento es un contrato entre quien escribe el formato y quien lo lee, sin red de seguridad.

returnEl valor de retorno

Entrega: ft_printf.cAutorizado: write

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

Qué te obliga a aprender — Que el valor de retorno es parte de la interfaz tanto como lo que sale por pantalla, y que los errores hay que propagarlos hacia arriba en lugar de ignorarlos. 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.

%c %s %%Caracteres y cadenas

Entrega: ft_print_chars.cAutorizado: write, free (+ libft: ft_strlen)
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.

Qué te obliga a aprender — Que «imitar printf» significa imitar una implementación concreta (aquí, glibc en Linux) incluso en casos que el estándar deja abiertos. Y que la conversión a unsigned char no es decorativa: así se pasa a write exactamente un byte con el valor que pidió quien llamó.

%d %i %uNúmeros en base 10

Entrega: ft_print_nbrs.c, ft_print_chars.cAutorizado: malloc, free (+ libft: ft_itoa, ft_itoa_base)
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.

Qué te obliga a aprender — A reutilizar en lugar de reescribir: la libft existe para esto. A cambio aparece una responsabilidad nueva, porque cada número impreso cuesta un 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.

%x %X %pHexadecimal y punteros

Entrega: ft_print_hex.cAutorizado: write, malloc, free (+ libft: ft_itoa_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.

Qué te obliga a aprender — Que un puntero es, al final, un número — una dirección — y que imprimirlo es imprimir ese número en base 16. De paso obliga a pensar en tamaños: 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.

makeEl Makefile y la libft

Entrega: Makefile, libft/Autorizado: ar (libtool prohibido)
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.

Qué te obliga a aprender — Que una librería estática es un contenedor de objetos que se puede ampliar, y que las dependencias entre proyectos se resuelven con Makefiles que se llaman unos a otros (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.

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

Argumentos variables

¿Cómo sabe 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_*

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

¿Por qué pasas &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_*

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

Casos límite

¿Qué imprimes con %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

¿Qué sale con 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

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

¿Hiciste el bonus? ¿Qué hace con %-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

Memoria y errores

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

¿Hay leaks? ¿Qué pasa si falla un 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

¿Por qué no usas un buffer, como el printf de verdad?

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

Makefile y Norma

¿Cómo entra la libft en 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

Si te piden añadir una conversión nueva, ¿qué tocas?

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