Diferencia entre revisiones de «Material»

• Completada la plantilla del juego de la vida
• Completado README.md

• Se utiliza un array de 3 dimensiones para guardar los 2 mundos
• Se van intercambiando los mundos "actual" y "siguiente" en cada iteración
• Se elimina la función `gol_copy`, ahora innecesaria

• Se crean "gol.h" y "gol.c"
• Se crea un makefile para compilar y limpiar el repositorio
• Se añade un .gitignore para ignorar los productos de la compilación

• Se encapsulan las variables `worlds` y `current_world` en la estructura `gol`
• La función `gol_step` se encarga ahora de gestionar la variable `curren_world`

• Se ocultan `gol_get_cell` y `gol_count_neighbours`
• Se declaran como `static` y se elimina el prefijo `gol_`

Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para crear dos ejecutables distintos según convenga.

• Ahora los mundos se reservan dinámicamente con `malloc`
• La nueva función `gol_alloc` se encarga de la esta reserva y `gol_free` de la liberación
• Cada mundo es un puntero a un puntero a un boleano, ie un vector de vectores. Se realiza una llamada a malloc para guardar un vector de punteros a filas y luego se realiza otra llamada por cada fila para reservarla.
• Para guardar la referencia a los dos mundos se utiliza un array de dos punteros. El mundo actual y el próximo siempre están en la misma posición de este array, y en cada iteración se intercambian las direcciones de los dos punteros.
• Se usa un enumerado para identificar los índices del mundo actual y el siguiente

• Se crea un nuevo archivo `mem_test.c` con otro `main()` que realiza un número finito de iteraciones del juego sin requerir la interacción del usuario, ni imprimir nada por pantalla
• Se añade un nuevo objetivo (`test`) al makefile que primero compilar el ejecutable `mem_test` con opciones de depuración y con todas las optimizaciones. Después lanzará este ejecutable con valgrind para comprobar fugas de memoria

• Los mundos son un único puntero a un bloque de memoria dónde está la matriz entera. Se realiza una llama a malloc por mundo.
• Ahora hay que calcular el offset de cada célula a mano, por lo que los accesos al mundo siempre se hacen a través de `get_cell` y la nueva función `set_cell`
• Las funciones `set_cell` y `get_cell` reciben el mundo sobre el que actuar (actual o siguiente)
• Se saca la lógica para comprobar los límites del mundo a la función `fix_coords` para poder utilizarla en `set_cell` y `get_cell` sin repetir código

Utilizar una macro para reutilizar y evitar repetir el mismo código en `get_cell` y `set_cell`

• La memoria para los dos mundos se reserva de una vez. La referencia a este bloque de memoria se guarda en la estructura del objeto
• Se utiliza la misma lógica que antes para acceder a las células, con dos punteros a los mundos que vamos intercarbiando.