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).
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.
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.
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.
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.
.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.
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.
#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).
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.
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.
? :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.
-R CheckDefineLa 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).
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.
. 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.
malloc y freemalloc(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.
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.
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.
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.
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
.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.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.
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.Una sola macro que sustituye su parámetro por su valor absoluto:
# define ABS(Value) (((Value) < 0) ? -(Value) : (Value))
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.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;
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.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.
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.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++;
}
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.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ú.
#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
.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
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
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
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
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 ->
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
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
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
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
""?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
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