C Piscine — C 08

El módulo del preprocesador. Aquí no se escriben apenas funciones: se escriben cabeceras (.h). Se aprende para qué existe el #include, qué es una macro, cómo se declara un struct y cómo se agrupan datos en memoria. 6 ejercicios (ex00–ex05).

El preámbulo — El enunciado abre con la entrada de Wikipedia sobre el ornitorrinco: un mamífero que pone huevos, con pico de pato y espolón venenoso, que los naturalistas europeos tomaron por una broma. Cierra con el clásico de la casa: "este enunciado no tiene nada que ver con el ornitorrinco". El guiño encaja con el módulo: la cabecera es esa pieza rara que no es del todo código ejecutable ni del todo documentación.

GGlosario de teoría

C 08 casi no tiene funciones: tiene cabeceras, macros y tipos, y cada uno trae su vocabulario. Aquí está cada palabra explicada desde cero y con un ejemplo sacado del propio módulo. En el resto de la página, la primera vez que sale uno de estos términos en cada tarjeta lleva un enlace a su entrada.

Del .c al ejecutable

Compilación por separado y enlazador

El compilador trabaja con un .c cada vez y lo convierte en un archivo objeto (.o) con el código máquina de sus funciones. Mientras compila ft_show_tab.c no ve nada de ft_strs_to_tab.c: para él, lo que no está en ese archivo (o en lo que ese archivo incluye) no existe. Después, el enlazador (linker) junta todos los .o y conecta cada llamada con la función que la resuelve.

De ahí salen dos errores distintos: si usas una función sin declararla, se queja el compilador; si la declaras pero nadie la define, se queja el enlazador (undefined reference); y si la definen dos .o, también el enlazador (multiple definition). Las cabeceras existen para que cada .c sepa qué hay en los demás sin tener su código.

Preprocesador

Un programa que pasa por el .c antes que el compilador y que solo hace trabajo de texto: obedece las líneas que empiezan por # (#include, #define, #ifndef…), las borra y entrega al compilador el texto resultante. No sabe nada de tipos ni de funciones: corta, pega y sustituye.

Se puede ver lo que produce con cc -E archivo.c. Con el main de ex01, la línea if (ft_is_even(argc - 1) == TRUE) le llega al compilador como if (ft_is_even(argc - 1) == 1): el compilador nunca llega a ver la palabra TRUE.

#include: comillas frente a < >

#include pega, en ese punto, el contenido entero del archivo indicado. Con comillas (#include "ft_stock_str.h") se busca primero en la carpeta del propio .c (y en las que se añadan con -I); con ángulos (#include <unistd.h>), solo en las carpetas del sistema. Por convención, comillas para tus cabeceras y ángulos para las de la biblioteca estándar.

En ex01 se ve para qué sirve: el main del enunciado llama a write sin incluir <unistd.h>; como incluye ft_boolean.h y esta incluye <unistd.h>, el prototipo de write acaba pegado igualmente antes del main.

Declaración, definición y prototipo

Una definición es la función entera, con su cuerpo entre llaves. Una declaración solo anuncia que existe: nombre, tipo de retorno y tipos de los parámetros, acabada en ;. Esa declaración completa es el prototipo. Con él, el compilador ya puede comprobar que la llamas bien, aunque el código esté en otro archivo.

ex00 entero son cinco prototipos, como int ft_strlen(char *str);. Una función se puede declarar tantas veces como quieras, pero definirse solo una: por eso en un .h van declaraciones y no definiciones.

Archivo de cabecera (.h)

Un archivo pensado para ser incluido, no para compilarse solo. Reúne lo que varios .c necesitan compartir: prototipos, typedef, structs y macros. La «h» es de header, cabecera, porque se incluye al principio.

En C 08 cada ejercicio, menos los dos últimos, es solo una cabecera: ft.h, ft_boolean.h, ft_abs.h y ft_point.h. Y ft_stock_str.h es la que comparten ex04 y ex05 para usar el mismo struct.

Include guard (guarda de inclusión)

Tres líneas del preprocesador que impiden que el contenido de una cabecera se pegue dos veces en el mismo .c:

#ifndef FT_H     /* si FT_H todavía no existe… */
# define FT_H    /* …créalo… */
…                /* …y deja pasar el contenido */
#endif           /* la segunda vez FT_H ya existe y se salta todo */

Hace falta porque las cabeceras se incluyen unas a otras y es fácil que una llegue dos veces. Un prototipo repetido no molesta, pero un struct sí. Con el ft_point.h del repo, que no tiene guard, incluirlo dos veces da:

ft_point.h:13:16: error: redefinition of ‘struct s_point’

La Norma pide que la macro se llame como el archivo, en mayúsculas y con _H: ft_boolean.h → FT_BOOLEAN_H.

Macros

Macro (#define)

Una regla de sustitución de texto para el preprocesador. Hay dos clases. La macro constante pone un nombre a un valor: con # define TRUE 1, cada TRUE del código pasa a ser 1. La macro con parámetros parece una función: con # define EVEN(x) ((x) % 2 == 0), EVEN(nbr) pasa a ser ((nbr) % 2 == 0).

Pero no es una función: no hay llamada ni retorno, no se comprueban tipos y el argumento no se calcula antes, sino que se copia tal cual allí donde aparece el parámetro. Es rápida porque no existe en tiempo de ejecución, y peligrosa por lo mismo (ver las dos entradas siguientes).

Precedencia de operadores y los paréntesis de las macros

La precedencia decide qué operador se aplica primero cuando no hay paréntesis: 2 + 3 * 4 es 14 porque * va antes que +. El signo menos de delante (-x) va antes que la resta.

En una macro eso muerde porque el argumento se pega como texto. Si ABS fuera (x < 0 ? -x : x), ABS(a - b) se convertiría en (a - b < 0 ? -a - b : a - b), y -a - b no es -(a - b). Por eso cada parámetro va entre paréntesis y la expresión entera también: ((x) < 0 ? -(x) : (x)). Con eso, ABS(2 - 7) da 5.

Efecto secundario y doble evaluación

Una expresión tiene un efecto secundario (o efecto lateral) cuando, además de dar un valor, cambia algo: x++ vale x y además suma 1 a x; una llamada a write imprime.

Si el parámetro de una macro aparece dos veces, el argumento se escribe dos veces y su efecto se produce dos veces. Con el ABS del repo y x = -1, ABS(x++) se expande a ((x++) < 0 ? -(x++) : (x++)): el primer x++ compara −1 y deja x en 0, el segundo devuelve -0 y deja x en 1. Ejecutado, imprime 0 y x=1: ni el valor absoluto de −1 ni un solo incremento. Una función de verdad habría dado 1 y x = 0.

Operador ternario ? :

condición ? a : b vale a si la condición es cierta y b si no. Es un if/else que, en vez de ejecutar instrucciones, da un valor, y por eso cabe dentro de una expresión o de una macro. Se llama ternario porque es el único operador de C con tres operandos.

Lo usan el main de ex01 ((EVEN(nbr)) ? TRUE : FALSE) y ABS. La Norma lo prohíbe en tu código; aquí se puede porque el enunciado lo pone y porque estos ejercicios se pasan con -R CheckDefine.

Norminette y -R CheckDefine

La norminette comprueba que el código cumple la Norma de 42, y la Moulinette la pasa antes de corregir: si da error, el ejercicio no puntúa. La Norma solo admite #define de constantes. Pasada sin flag, el ft_abs.h del repo da:

Error: MACRO_FUNC_FORBIDDEN (line:  13, col:  13):	Macro functions are forbidden
Error: PREPROC_CONSTANT     (line:  13, col:  17):	Preprocessor statement must only contain constant defines
Error: TERNARY_FBIDDEN      (line:  13, col:  26):	Ternaries are forbidden

Por eso el enunciado dice que ex01 y ex02 se pasan con norminette -R CheckDefine: con ese flag esas tres desaparecen y quedan las demás reglas, como el sangrado (ver la sección de preguntas).

Tipos y memoria

typedef (alias de tipo)

typedef da otro nombre a un tipo que ya existe. No crea un tipo nuevo: el compilador trata los dos nombres como el mismo. Sirve para que el código diga lo que significa el dato.

typedef int t_bool; hace que t_bool sea un int que, por el nombre, se lee como «sí o no». Y typedef struct s_point {…} t_point; permite escribir t_point en vez de struct s_point. La Norma pide el prefijo t_ para los typedef y s_ para los structs.

struct (estructura)

Un tipo hecho a mano que junta varias variables, los campos, bajo un nombre. Se guardan seguidas en memoria, en el orden en que se declaran (el compilador puede dejar huecos de relleno entre ellas para alinearlas).

t_point tiene dos int, x e y. t_stock_str tiene un int y dos punteros: en una máquina de 64 bits ocupa 16 bytes de datos y 4 de relleno tras size, 24 en total. Por eso el malloc de ex04 se escribe sizeof(t_stock_str) * (ac + 1) y no con números a mano.

Los operadores . y ->

El punto accede a un campo de un struct: point.x. La flecha hace lo mismo a través de un puntero al struct: point->x es exactamente (*point).x, primero se va a la dirección y luego se coge el campo. Los paréntesis de (*point).x son obligatorios, porque el punto va antes que el asterisco.

El main de ex03 usa la flecha porque set_point recibe un t_point *. En ex05 se usa el punto, par[i].str, porque par[i] ya es el struct, no un puntero.

Memoria dinámica: malloc y free

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 memoria. free devuelve esa memoria. Se usa cuando el tamaño no se sabe hasta que el programa corre, o cuando el dato tiene que sobrevivir a la función que lo crea.

ex04 hace las dos cosas: el número de structs depende de ac y el array tiene que seguir vivo cuando ft_strs_to_tab termina, para que lo use ft_show_tab. Una variable local no serviría: desaparece con la función.

Valor centinela

Un valor especial que marca el final de una secuencia, para no tener que guardar su longitud aparte. Quien la recorre avanza hasta encontrarlo. El '\0' de las cadenas y el NULL que hay tras el último argv son centinelas.

En ex04 se reservan ac + 1 structs y el último lleva str = 0. Así ft_show_tab, que solo recibe el puntero, sabe dónde parar. El centinela tiene que ser un valor que no pueda aparecer en los datos: str = 0 sirve porque ningún argumento es un puntero nulo; size == 0 no sirve, porque "" es un argumento válido de longitud 0.

Error por uno (off-by-one) y desbordamiento de buffer

Un error por uno es un bucle o una cuenta que se pasa o se queda corta en exactamente un elemento: <= donde iba <, olvidar el + 1 del '\0'… Si se pasa al escribir, escribe fuera de la memoria reservada: un desbordamiento de buffer. A veces no pasa nada visible, a veces se corrompe otro dato y el programa falla mucho después, lejos del error.

Valgrind lo detecta aunque el programa parezca funcionar. Con el ft_strifcpy del repo dice Invalid write of size 1 … 0 bytes after a block of size 4: reserva len + 1 bytes, copia len + 1 (el bucle va hasta <=) y luego escribe un '\0' más.

Fuga de memoria (leak)

Memoria reservada con malloc que nadie libera y cuya dirección ya se ha perdido: no se puede recuperar hasta que el programa termina. En un programa corto no se nota; en uno que corre mucho tiempo se va comiendo la memoria. Se buscan con valgrind --leak-check=full.

En ex04 hay ac + 1 bloques: uno por cada copy y el del array. Quien llama a ft_strs_to_tab es quien tiene que liberarlos: primero cada copy y luego el array. Los str no, porque apuntan a av, que no se reservó con malloc.

ex00ft.h

Entregable: ft.hFunciones autorizadas: ninguna

Crear un archivo de cabecera con los prototipos de cinco funciones:

#ifndef FT_H
# define FT_H

void	ft_putchar(char c);
void	ft_swap(int *a, int *b);
void	ft_putstr(char *str);
int	ft_strlen(char *str);
int	ft_strcmp(char *s1, char *s2);

#endif
Por qué existen los .h — El compilador de C procesa cada .c por separado y no sabe nada de las funciones que viven en otro archivo. Un prototipo es una promesa: "esta función existe, se llama así y tiene estos tipos". El #include "ft.h" no es magia — el preprocesador literalmente pega el contenido del .h en el punto del #include antes de compilar. Por eso una cabecera solo debe declarar, no definir: si dos .c incluyen el mismo .h con código dentro, ese código se duplica y el enlazador se queja. El #ifndef FT_H / #define FT_H / #endif es el include guard: si un mismo archivo se incluye dos veces (algo habitual con cabeceras que se incluyen entre sí), la segunda vez la macro FT_H ya está definida y todo el bloque se salta. Sin él, redefiniciones y errores. La Norma exige el guard con el nombre del archivo en mayúsculas.

ex01ft_boolean.h

Entregable: ft_boolean.hNorminette: -R CheckDefine

El enunciado da un main ya escrito y hay que crear la cabecera que lo haga compilar y funcionar: cuenta si el número de argumentos es par o impar.

# include <unistd.h>

# define EVEN_MSG "I have an even number of arguments.\n"
# define ODD_MSG "I have an odd number of arguments.\n"
# define SUCCESS 0
# define TRUE 1
# define FALSE 0
# define EVEN(nbr) ((nbr) % 2 == 0)

typedef int	t_bool;

La cabecera aporta todo lo que el main usa sin definir: el tipo t_bool (un simple int con nombre con intención), las constantes TRUE/FALSE/SUCCESS, los mensajes y la macro EVEN. Incluye <unistd.h> porque el main llama a write sin incluirlo él mismo.

Macros y typedef — Una macro #define es sustitución de texto pura, antes de compilar: donde ponga EVEN(x) el preprocesador escribe ((x) % 2 == 0). No es una función: no hay llamada, no hay tipos, no hay coste en tiempo de ejecución. El typedef int t_bool no crea un tipo nuevo, solo un alias: sirve para que el código se lea con intención (t_bool dice "esto es un sí/no", aunque por dentro sea un entero). El flag -R CheckDefine hace que la norminette vigile expresamente el estilo de las macros: constantes en mayúsculas y bien formadas.

ex02ft_abs.h

Entregable: ft_abs.hNorminette: -R CheckDefine

Una sola macro que sustituye su parámetro por su valor absoluto:

# define ABS(Value) (((Value) < 0) ? -(Value) : (Value))
Los paréntesis no son decorado — En una macro, cada aparición del parámetro tiene que ir entre paréntesis, y el resultado entero también. Como la macro es sustitución de texto, ABS(a - b) sin paréntesis se expandiría a -a - b (que no es -(a-b)) y romper la precedencia. Con -(Value) y el paréntesis exterior, la expansión respeta el operando completo. Es el peligro clásico de las macros frente a las funciones: no evalúan argumentos, copian texto. Por eso también ABS(x++) incrementaría x dos veces — una macro no es una función, aunque lo parezca.

ex03ft_point.h

Entregable: ft_point.h

Una cabecera que declare un tipo t_point con dos enteros, de modo que compile el main del enunciado (que hace point->x = 42; point->y = 21;).

typedef struct s_point
{
	int	x;
	int	y;
}	t_point;
Structs: agrupar datos en memoria — Un struct es un molde para poner varias variables juntas bajo un mismo nombre, contiguas en memoria. Aquí un t_point ocupa dos int seguidos; point.x es el primero y point.y el siguiente. El detalle de estilo 42: la estructura se llama s_point y el alias t_point (prefijos s_ de struct y t_ de type). El -> del main es azúcar para "desreferencia el puntero y accede al campo": point->x es (*point).x. Entender que un struct es solo memoria contigua es la base de todo lo que viene después: arrays de structs, listas enlazadas, y la gestión manual de memoria.

ex04ft_strs_to_tab

Entregable: ft_strs_to_tab.cFunciones: malloc, free

Transformar un array de cadenas (los argumentos) en un array de estructuras t_stock_str, cada una con el tamaño de la cadena, la cadena original y una copia:

typedef struct s_stock_str
{
	int		size;
	char	*str;
	char	*copy;
}	t_stock_str;

Se reserva memoria para ac + 1 estructuras; la última hace de centinela con str = 0 para marcar el final. La copia se hace con un ft_strdup propio (reservar len + 1 y copiar carácter a carácter). Si algún malloc falla, se devuelve NULL.

Array de structs y el centinela — Aquí se juntan dos ideas: reservar memoria dinámica (malloc) para un número de elementos que no se sabe hasta ejecución, y usar un valor centinela para marcar el final en vez de llevar la cuenta aparte (el mismo patrón que el '\0' al final de las cadenas, o el NULL al final de argv). Reservar ac + 1 y dejar la última con str = 0 permite recorrer el array sin conocer su longitud. La copia existe para que el ejercicio siguiente pueda modificarla sin tocar el original: el struct guarda el dato y una versión de trabajo.

ex05ft_show_tab

Entregable: ft_show_tab.cFunciones: write

Recorrer el array creado por el ejercicio anterior y mostrar, por cada estructura: la cadena, su tamaño y la copia, cada uno seguido de un salto de línea.

while (par[i].str)
{
	ft_putstr(par[i].str);
	write(1, "\n", 1);
	ft_putnbr(par[i].size);
	write(1, "\n", 1);
	ft_putstr(par[i].copy);
	write(1, "\n", 1);
	i++;
}
Recorrer hasta el centinela — El bucle no necesita saber cuántos elementos hay: avanza mientras par[i].str no sea NULL, que es justo la marca de fin que dejó ft_strs_to_tab. Este par de ejercicios (ex04 construye, ex05 consume) es el primer contacto con el patrón productor/consumidor sobre una estructura de datos propia, y con el hecho de que solo se dispone de write: no hay printf, así que hay que escribir a mano un ft_putnbr para imprimir el tamaño dígito a dígito.

?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: cabeceras, macros, structs y memoria, y puntos débiles del código del repo. Antes de mirar la respuesta, intenta contestar tú.

Cabeceras

¿Para qué sirven el #ifndef, el # define y el #endif?

Son el include guard: la primera vez que se incluye la cabecera definen la macro (FT_H) y dejan pasar el contenido; la segunda vez la macro ya existe y se salta todo. Sin él, un struct incluido dos veces no compila: redefinition of ‘struct s_point’. → ex00, include guard

¿Por qué en un .h van prototipos y no el código de las funciones?

Porque #include pega el archivo entero en cada .c que lo incluye. Si llevara definiciones, cada .o tendría su copia de la función y el enlazador fallaría con multiple definition. Declarar se puede muchas veces; definir, una. → ex00, compilación por separado

Macros

¿Qué diferencia hay entre la macro ABS y una función ft_abs?

La macro es texto que el preprocesador pega antes de compilar: no hay llamada, no se comprueban tipos y el argumento se copia cada vez que aparece el parámetro, sin calcularse antes. Con x = -1, ABS(x++) da 0 y deja x en 1, porque el x++ se ejecuta dos veces. → ex02, doble evaluación

¿Por qué ABS lleva tantos paréntesis?

Para que el argumento y el resultado se comporten como un solo valor sea cual sea la expresión que se pase. Sin ellos, ABS(a - b) calcularía -a - b, y 2 * ABS(x) mezclaría el * con la condición del ternario. → ex02, precedencia

¿Una macro con parámetros pasa la norminette?

No con la norminette normal: da MACRO_FUNC_FORBIDDEN y PREPROC_CONSTANT, y el ternario TERNARY_FBIDDEN. Por eso el enunciado manda pasar ex01 y ex02 con -R CheckDefine, y la Moulinette también lo hace. Con ese flag quedan las demás reglas: el ft_abs.h del repo sigue dando TOO_MANY_WS por el espacio de # define fuera de un guard, y ft_boolean.h, TAB_REPLACE_SPACE por el tabulador de typedef int. → -R CheckDefine

Structs y memoria

¿Por qué en ex03 se escribe point->x y en ex05 par[i].str?

Porque en ex03 point es un puntero a t_point, y la flecha es «desreferencia y coge el campo»: (*point).x. En ex05 par[i] ya es el struct (los corchetes ya desreferencian), así que basta el punto. → ex03, . y ->

¿Por qué reservas ac + 1 structs y cómo sabe ft_show_tab dónde parar?

El de más es el centinela: el enunciado pide que el último tenga str a 0. ft_show_tab solo recibe el puntero, sin la longitud, y avanza hasta encontrarlo. → ex04, centinela

¿Quién libera la memoria de ft_strs_to_tab, y qué hay que liberar?

Quien la llama, porque la función devuelve el array. Hay que hacer un free de cada copy y otro del array, en ese orden (si liberas antes el array pierdes los punteros a las copias). Los str no se liberan: apuntan a av. Y si un malloc falla a mitad, lo correcto es liberar lo ya reservado antes de devolver NULL. → fuga de memoria

Puntos débiles del código del repo (mejor tener la respuesta preparada)

¿Qué devuelve tu ft_strs_to_tab si falla un malloc?

El enunciado pide NULL, pero el código del repo no comprueba ningún malloc: si falla el del array, escribe en la dirección 0 y el programa muere; si falla el de una copia, lo hace ft_strifcpy. Hay que comprobar cada uno. La versión de la tarjeta lo describe así. → ex04, malloc

¿Pasa valgrind tu ft_strs_to_tab?

No sin errores: ft_strifcpy(av[i], 0, size) reserva size + 1 bytes, copia size + 1 (el bucle llega hasta i <= fin - ini) y luego escribe el '\0' en la posición size + 1, un byte fuera. Valgrind lo marca como Invalid write of size 1. La salida por pantalla es correcta, y por eso no se nota. → error por uno

¿Qué pasa si uno de los argumentos es la cadena vacía ""?

Con el código del repo, ft_show_tab se para ahí: su bucle es while (par[i].size) y no while (par[i].str). Ejecutado con ./t hola "" mundo, muestra ./t y hola y no llega a mundo. El centinela que fija el enunciado es str == 0. → ex05, centinela

¿Tienes también una macro ODD?

El enunciado no la pide, pero el test avisa de que se pregunta en la defensa. En el repo está como # define ODD(X) ((x) % 2 !=0): el parámetro es X y el cuerpo usa x, así que en cuanto se usa ODD(3) no compila (‘x’ undeclared). Mientras nadie la use no se nota, porque una macro solo se comprueba al expandirse. → macro