El primer proyecto en grupo. Una función, rush(x, y), que dibuja un
rectángulo de x columnas por y filas con letras en las esquinas y los
bordes. Solo con write, y con un fin de semana para ponerse de acuerdo con gente que
no conocías el viernes.
Qué es un rush — Los rushes son los proyectos de fin de semana
de la piscine: el sistema te asigna un grupo de dos o tres personas y hay que entregar en el
repositorio común antes del domingo por la noche. No hay Moulinette: se defiende en una
evaluación en directo donde
cualquier miembro del grupo tiene que poder explicar
cualquier línea. En el Rush 00 cada grupo recibe una de cinco variantes del mismo dibujo (cambian
los caracteres de las esquinas y los bordes). La de este grupo pone
A en la esquina
superior izquierda y en la inferior derecha,
C en las otras dos y
B en
los bordes — el patrón de la variante que el enunciado llama
rush04, aunque el fichero
se llame
rush00.c. En el pack no está el PDF del enunciado; lo que sigue sale del
código.
$> ./a.out (rush(5, 3))
ABBBC
B B
CBBBA
El código es del grupo (la cabecera 42 de los ficheros la firma el compañero, y
la última edición de
rush00.c es de xalara).
GGlosario de teoría
El Rush 00 es corto, pero toca casi todo lo básico de C: cómo sale un carácter por pantalla,
cómo se recorre una cuadrícula y cómo se juntan varios ficheros en un programa. Aquí está cada idea
explicada desde cero y con un ejemplo sacado del propio rush. 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.
Salida por pantalla
write: la única forma de escribir
write(fd, direccion, n) es una llamada al sistema: le pide al sistema operativo
que copie n bytes, empezando en direccion, al destino fd.
No sabe nada de números ni de formatos; solo copia bytes. Por eso el enunciado prohíbe
printf y obliga a construir lo demás encima.
En el rush, todo pasa por una función de tres líneas: ft_putchar(c) hace
write(1, &c, 1), es decir, «escribe en la salida estándar 1 byte, el que hay en
la dirección de c». El & hace falta porque write pide
una dirección, no un valor.
Descriptor de fichero y salida estándar
Un descriptor de fichero (file descriptor, fd) es un número pequeño con el
que el programa se refiere a algo donde se puede leer o escribir: un fichero, la terminal, una
tubería. Todo programa arranca con tres abiertos: el 0 es la entrada estándar (stdin), el 1 la
salida estándar (stdout) y el 2 la salida de errores (stderr).
El rush escribe siempre en el 1. Si lo ejecutas con ./a.out | cat -e, la salida
no va a la pantalla sino a cat, que marca cada fin de línea con un $: es
la forma de ver si sobran o faltan espacios al final de las filas.
char y la tabla ASCII
Un char es un entero de un byte. Lo que lo convierte en «letra» es la tabla ASCII,
el acuerdo que dice qué número corresponde a cada carácter: 'A' es 65,
'B' 66, 'C' 67, el espacio ' ' es 32 y el salto de línea
'\n' es 10. Escribir 'A' entre comillas simples es solo una forma
legible de escribir 65.
Cada ft_putchar('B') del rush manda a la terminal el byte 66, y es la terminal la
que dibuja la B.
Salto de línea: la salida es una fila de bytes
La pantalla parece una cuadrícula, pero lo que el programa produce es una sola secuencia de
bytes. El salto de línea '\n' es un byte más que le dice a la terminal «sigue en la
línea de abajo». Sin él, todo el rectángulo saldría en una sola fila.
rush(5, 3) escribe 5 caracteres y un '\n' por fila, tres veces: 18
bytes en total, que la terminal muestra como tres líneas de cinco.
Recorrer la cuadrícula
Bucles anidados
Un bucle dentro de otro: por cada vuelta del exterior, el interior da todas las suyas. Es la
forma natural de recorrer algo de dos dimensiones. El número total de vueltas del interior es el
producto de los dos: filas × columnas.
En rush, el exterior recorre las filas (i, de 1 a y) y
el interior las columnas (j, de 1 a x). rush(123, 42), el
último caso del main, llama 123 × 42 = 5166 veces a print_character. Si
se cambiaran de sitio los dos bucles, el dibujo saldría traspuesto: y columnas por
x filas.
Contar desde 0 o desde 1
En C los arrays empiezan en 0, y por costumbre los contadores también: i = 0;
while (i < n) da n vueltas con i de 0 a n−1. Pero un contador que no indexa
ningún array puede empezar donde sea más claro: i = 1; while (i <= n) da las mismas
n vueltas, con i de 1 a n.
El rush usa la segunda forma: «primera fila» es i == 1 y «última» es
i == y. Con contadores desde 0 las condiciones serían i == 0 e
i == y - 1, igual de correctas pero más fáciles de equivocar en un
-1.
Cadena if / else if
Una serie de condiciones en la que se evalúan en orden y solo se ejecuta la rama de la
primera que se cumple; las de detrás ni se miran. Si ninguna se cumple, va al
else final. Cuando dos condiciones se pueden cumplir a la vez, el orden decide cuál
gana.
En print_character una esquina cumple también «está en un borde». Como las esquinas
se preguntan antes, sale A o C; si la pregunta del borde fuera la
primera, las esquinas saldrían como B.
Operadores lógicos y precedencia
&& («y») es cierto si lo son los dos lados; || («o») si lo es
al menos uno. Los dos se evalúan de izquierda a derecha y se paran en cuanto saben el resultado (en
A || B, si A es cierto, B no se evalúa). Y && tiene más
precedencia que ||: se agrupa antes, igual que la multiplicación antes que la
suma.
Por eso los paréntesis de (i == 1 && j == 1) || (i == y && j == x)
no cambian el resultado: sin ellos se agruparía igual. Aun así ayudan a leerlo como «esquina de
arriba a la izquierda o esquina de abajo a la derecha».
Caso límite (caso degenerado)
Una entrada en el extremo de lo posible, donde el problema se deforma: cero, negativos, un solo
elemento, el valor más grande. En el caso general las reglas no chocan, y en el límite sí, por eso
es donde aparecen los fallos.
En el rush: rush(0, 6) y rush(-1, 6) no deben dibujar nada (el
if (x <= 0 || y <= 0) lo resuelve); rush(1, 1) es a la vez las
cuatro esquinas; y rush(5, 1) tiene una celda que es «última columna» de la primera
fila y de la última a la vez.
Compilar y entregar
Prototipo (declaración de una función)
El compilador lee cada .c de arriba abajo y por separado. Para poder llamar a una
función que está en otro fichero necesita saber antes cómo es: su nombre, qué recibe y qué
devuelve. Eso es el prototipo: la primera línea de la función terminada en
;, sin cuerpo.
rush00.c empieza con void ft_putchar(char c); porque la función vive
en ft_putchar.c, y main.c con void rush(int x, int y); por
lo mismo. Sin ese prototipo, -Werror convierte el aviso de «declaración implícita» en
un error y no compila.
Compilación separada y enlazado
Compilar un programa de varios ficheros son dos pasos: cada .c se traduce por
separado a código máquina (un fichero objeto), y después el enlazador (linker)
los junta y conecta cada llamada con la función que le corresponde, esté en el fichero que esté.
Tiene que haber exactamente un main y ninguna función definida dos veces.
El rush se compila con cc -Wall -Wextra -Werror ft_putchar.c main.c rush00.c: tres
traducciones y un enlazado que produce a.out. En la evaluación se cambia
main.c por otro y el resto no se toca.
-Wall -Wextra -Werror
Opciones del compilador. -Wall y -Wextra activan muchos avisos
(variables sin usar, comparaciones sospechosas, funciones sin declarar…) y -Werror
convierte cualquier aviso en error, así que el programa no compila si hay alguno. En 42 son
obligatorias: si no compila con ellas, la nota es 0.
Los tres ficheros del rush compilan con las tres sin un solo aviso.
La Norma y norminette
La Norma es el reglamento de estilo de 42: como mucho 25 líneas por función y 5 funciones por
fichero, tabulaciones para sangrar, declaraciones al principio de la función, nada de
for, cabecera de 42 en cada fichero… norminette es el programa que lo
comprueba, y un error de Norma es un 0.
Las condiciones largas de print_character están partidas en dos líneas para no
pasar de 80 columnas. norminette sobre ex00/ da OK! en los
tres ficheros.
ex00rush
Entrega: ex00/rush00.c, ex00/ft_putchar.c, ex00/main.cAutorizado: write
Recorre el rectángulo fila a fila (i, de 1 a y) y, dentro de cada
fila, columna a columna (j, de 1 a x). Cada celda se delega a
print_character y al final de cada fila se escribe el salto de línea. Las medidas
nulas o negativas no dibujan nada.
void rush(int x, int y)
{
int i;
int j;
if (x <= 0 || y <= 0)
return ;
i = 1;
while (i <= y)
{
j = 1;
while (j <= x)
{
print_character(i, j, x, y);
j++;
}
ft_putchar('\n');
i++;
}
}
Un detalle que facilita la lectura: los contadores empiezan en 1, no en 0. Así «primera
fila» es i == 1 y «última fila» es i == y, que se parece mucho a cómo
se describe el dibujo en español.
Qué te obliga a aprender — A pensar una salida en dos dimensiones
como una secuencia de bytes: la pantalla no es una cuadrícula, es un flujo de caracteres donde
'\n' marca dónde empieza la siguiente fila. El
bucle exterior son las filas y el
interior las columnas, y confundirlos (o el orden de
x e
y) es el error
típico que la defensa busca.
celdaprint_character
Entrega: ex00/rush00.cAutorizado: write (vía ft_putchar)
Toda la lógica del dibujo está en una cadena de if / else if que decide la letra
según la posición. El orden de las condiciones importa: primero las esquinas
A, luego las esquinas C, luego cualquier borde, y si no es nada de eso,
un espacio.
void print_character(int i, int j, int x, int y)
{
if ((i == 1 && j == 1)
|| (i == y && j == x))
ft_putchar('A');
else if ((i == 1 && j == x)
|| (i == y && j == 1))
ft_putchar('C');
else if (i == 1 || i == y
|| j == 1 || j == x)
ft_putchar('B');
else
ft_putchar(' ');
}
Qué te obliga a aprender — Que una cadena de
else if es una tabla de prioridades: la primera condición que se cumple gana. Las
esquinas también son borde, así que si la comprobación de borde fuera primero nunca saldría una
A ni una C. Separar «qué carácter va aquí» del «recorrer el rectángulo»
en dos funciones es además lo que hace que el código sea defendible por cualquiera del grupo.
mainmain
Entrega: ex00/main.cAutorizado: write
El enunciado de los Rush 00 deja que el grupo entregue su propio main, y en la
evaluación se cambia por otros valores. El de este grupo prueba casos normales y los bordes:
1×1, una fila, una columna, ceros, negativos y uno grande.
rush(6, 4);
rush(1, 1);
rush(1, 4);
rush(4, 1);
rush(2, 2);
rush(0, 6);
rush(6, 0);
rush(0, 0);
rush(-1, 6);
rush(6, -1);
rush(-3, -5);
rush(123, 42);
Qué te obliga a aprender — A probar antes de que te prueben. Un
main que solo llama a rush(5, 3) no demuestra nada; uno con los casos degenerados
(0, negativos, 1×N) es la lista de lo que el evaluador va a intentar romper.
ojoUna sola fila o una sola columna
Afecta a: print_character
Con una sola fila (y == 1), la primera y la última fila son la misma. En la
última celda se cumplen a la vez «última fila y última columna» (A) y «primera fila
y última columna» (C), y como la comprobación de A va primero, gana la
A. Lo mismo pasa con una sola columna. Compilado y ejecutado tal cual:
rush(5, 1) rush(1, 5)
ABBBA A
B
B
B
A
Ojo: en esta variante del enunciado, los ejemplos de una fila y de una columna terminan en
C (ABBBC y A B B B C en vertical). Con los rectángulos de
dos o más filas y columnas (rush(5, 3), rush(4, 4)) la salida es la
esperada, y el 1×1 da A.
Qué te obliga a aprender — Que los
casos degenerados son donde
dos reglas que nunca chocan en el caso general empiezan a solaparse. Cuando una celda es a la vez
«primera» y «última», el orden de los
if deja de ser un detalle de estilo y pasa a
decidir el resultado.
?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. En un rush la pregunta puede ir a cualquiera del grupo, sobre
cualquier línea. Antes de mirar la respuesta, intenta contestar tú.
El código
¿Por qué las esquinas se comprueban antes que los bordes?
Porque una esquina también es borde, y en una cadena de
else if gana la primera condición que se cumple. Con el borde primero, las cuatro
esquinas saldrían como B. → print_character
¿Cuál es x y cuál es y? ¿Qué cambia si los cambio de sitio?
x son las columnas (el ancho) e y las filas (el alto). El bucle
exterior recorre las filas y el interior las columnas. rush(6, 4) da 4 líneas de 6
caracteres; rush(4, 6), 6 líneas de 4. → rush
¿Por qué los contadores empiezan en 1?
Para que las condiciones se lean como el dibujo: primera fila es i == 1 y última
i == y. Con contadores desde 0 serían i == 0 e i == y - 1;
funciona igual, pero es más fácil equivocarse en un -1. → contar
desde 0 o desde 1
Si te piden otra variante del dibujo, ¿qué tocas?
Solo print_character: las letras de cada ft_putchar y, si cambian las
esquinas que se emparejan, qué esquinas van en cada condición. rush no se toca, porque
solo recorre la cuadrícula. → print_character
Casos límite
¿Qué pasa con rush(0, 6) o con números negativos?
No se dibuja nada, ni un salto de línea: el if (x <= 0 || y <= 0) return ;
de rush sale antes de empezar: con el || basta con que una de las dos medidas no sea positiva. El main prueba 0 y negativos en cada
posición. → rush, main
¿Qué sale con rush(5, 1)?
ABBBA, y rush(1, 5) da A, B, B, B, A en vertical. Con una sola fila,
la última celda cumple la condición de A (última fila y última columna) y la de
C (primera fila y última columna), y gana la A porque va primero. Los
ejemplos de esta variante terminan en C: mejor tenerlo explicado antes de que lo
encuentre el evaluador. → una sola fila o una sola columna
¿Y con un rectángulo muy grande?
Funciona igual: no se reserva memoria, cada celda se escribe al momento. rush(123, 42)
está en el main. Lo único que limita es que x e y son
int; con tamaños enormes tardaría, porque son x · y llamadas a
write de un byte. → bucles anidados
Reglas de la piscine
¿Por qué ft_putchar y no printf?
Porque la única función autorizada es write. ft_putchar es
write(1, &c, 1): un byte, el código ASCII de la letra, a la salida estándar. → write,
descriptor de fichero
¿Pasa la Norma? ¿Compila con los flags?
Sí: norminette da OK! en los tres ficheros y cc -Wall -Wextra
-Werror compila sin avisos. Los prototipos al principio de rush00.c y
main.c son los que evitan el error de «declaración implícita».
→ la Norma, prototipo
¿Por qué entregáis un main.c aparte?
Porque en la evaluación lo cambian por el suyo con otros valores, y así se puede sustituir sin
tocar rush00.c. Los tres ficheros se compilan por separado y el enlazador los junta.
→ main, compilación separada
Sobre el trabajo en grupo
¿Quién hizo qué? ¿Cómo os organizasteis?
Esta te la tienes que preparar tú. La cabecera de rush00.c la firma un compañero y
la última edición es de xalara, pero en la defensa cualquiera del grupo tiene que poder explicar
cualquier línea. Si piden un cambio en directo, lo típico es otra variante de letras o el caso de
una sola fila. → print_character, ojo