Wiki del curso de C - Contribuciones del usuario [es]

Material

2019-06-26T18:15:15Z

Carfalgar: /* Tareas */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)
* [https://en.cppreference.com/w/c Documentación de C]
* [[:Archivo:Autotools.zip | Plantilla autotools]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)
# https://youtu.be/sq14oKSodPM
# https://youtu.be/JHUozE_4HPs
# https://youtu.be/cVDUGO0_saE
# https://youtu.be/Qq9u5Odq0jU

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-s <seed>] [-p <pattern>]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 9
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.2
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| 10
|
| Configura compilación con autotools
* Se mueve todo el código a una nueva carpeta `src/`
* Se crean los archivos necesarios para configurar autotools:
** `autogen.sh`
** `configure.ac`
** `makefile.am`
* Se elimina el `makefile` ya que este será generado por autotools
* Se añaden al `.gitignore` todos los archivos autogenerados de autotools
|-

| rowspan="4" | 11
| 11.1
| Objetos II: Implementar el objeto `gol_toroid` hijo de `gol`
En esta primera versión, se implementa una herencia usando punteros a funciones.

* El objeto `gol` contiene dos atributos nuevos, punteros a las funciones que implementarán la funcionalidad de `get_cell()` y `set_cell()`
* Los métodos estáticos `get_cell()` y `set_cell()` de `gol.c` simplemente llaman a los punteros a funciones del objeto.
* Se crea el objeto nuevo en dos archivos: `gol_toroid.c` y `gol_toroid.h`
* La interfaz de este objeto (funciones en `gol_toroid.h`) sólo añade dos métodos: un constructor y un destructor, `gol_toroid_alloc()` y `gol_toroid_free()`)
* En `gol_toroid.c` se implementan este constructor y este destructor, además de las funciones estáticas `get_cell()` y `set_cell()` cuyas direcciones se asignan a los punteros a funcion.
* Las funciones estáticas `get_cell()` y `set_cell()` de `gol_toroid.c` implementan un acceso toroidal al mundo
* Como en `gol_toroid.c` se necesita acceso a la estructura y a los métodos `gol_alloc()` y `gol_free()`, se vuelven a pasar a `gol.h`.
* Se modifica `mem_test` para que haga uso de este nuevo objeto
|-

| 11.2
| Objetos II: Implementar un nuevo objeto `gol_finite`
* Se implementa el objeto `gol_finite` igual que se implementó `gol_toroid`
* Este objeto implementa un mundo con límites, a partir de los cuales todas las células se consideran muertas
* Se modifica el main para que `getopt` interprete un nuevo argumento que seleccionará el tipo de mundo a instanciar.
* Se modifica `mem_test` para que compruebe los dos mundos
|-

| 11.3
| Objetos II: Privatizar la estructura gol y algunos métodos
* Se crea una paraja de archivos `gol_priv.h` y `gol_priv.c` que albergan las definiciones de `struct gol` y de los métodos `gol_alloc()` y `gol_free()`
* El resto de objetos incluyen este `gol_priv.h` para tener acceso a la estrucutra, constructor y destructor. Pero no se incluye en el `main.c`.
|-

| 11.4
| Objetos II: ...
|-

| ...
| ...
| ...

|}

Archivo:Slides prin.pdf

2019-06-12T14:59:55Z

Carfalgar: Carfalgar subió una nueva versión de Archivo:Slides prin.pdf

Archivo:Transparencias.pdf

2019-06-12T14:59:37Z

Carfalgar: Carfalgar subió una nueva versión de Archivo:Transparencias.pdf

Material

2019-06-12T14:47:41Z

Carfalgar: /* Vídeos */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)
* [https://en.cppreference.com/w/c Documentación de C]
* [[:Archivo:Autotools.zip | Plantilla autotools]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)
# https://youtu.be/sq14oKSodPM
# https://youtu.be/JHUozE_4HPs
# https://youtu.be/cVDUGO0_saE
# https://youtu.be/Qq9u5Odq0jU

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-r[<seed>]]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 9
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.2
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| 10
|
| Configura compilación con autotools
* Se mueve todo el código a una nueva carpeta `src/`
* Se crean los archivos necesarios para configurar autotools:
** `autogen.sh`
** `configure.ac`
** `makefile.am`
* Se elimina el `makefile` ya que este será generado por autotools
* Se añaden al `.gitignore` todos los archivos autogenerados de autotools
|-

| rowspan="4" | 11
| 11.1
| Objetos II: Implementar el objeto `gol_toroid` hijo de `gol`
En esta primera versión, se implementa una herencia usando punteros a funciones.

* El objeto `gol` contiene dos atributos nuevos, punteros a las funciones que implementarán la funcionalidad de `get_cell()` y `set_cell()`
* Los métodos estáticos `get_cell()` y `set_cell()` de `gol.c` simplemente llaman a los punteros a funciones del objeto.
* Se crea el objeto nuevo en dos archivos: `gol_toroid.c` y `gol_toroid.h`
* La interfaz de este objeto (funciones en `gol_toroid.h`) sólo añade dos métodos: un constructor y un destructor, `gol_toroid_alloc()` y `gol_toroid_free()`)
* En `gol_toroid.c` se implementan este constructor y este destructor, además de las funciones estáticas `get_cell()` y `set_cell()` cuyas direcciones se asignan a los punteros a funcion.
* Las funciones estáticas `get_cell()` y `set_cell()` de `gol_toroid.c` implementan un acceso toroidal al mundo
* Como en `gol_toroid.c` se necesita acceso a la estructura y a los métodos `gol_alloc()` y `gol_free()`, se vuelven a pasar a `gol.h`.
* Se modifica `mem_test` para que haga uso de este nuevo objeto
|-

| 11.2
| Objetos II: Implementar un nuevo objeto `gol_finite`
* Se implementa el objeto `gol_finite` igual que se implementó `gol_toroid`
* Este objeto implementa un mundo con límites, a partir de los cuales todas las células se consideran muertas
* Se modifica el main para que `getopt` interprete un nuevo argumento que seleccionará el tipo de mundo a instanciar.
* Se modifica `mem_test` para que compruebe los dos mundos
|-

| 11.3
| Objetos II: Privatizar la estructura gol y algunos métodos
* Se crea una paraja de archivos `gol_priv.h` y `gol_priv.c` que albergan las definiciones de `struct gol` y de los métodos `gol_alloc()` y `gol_free()`
* El resto de objetos incluyen este `gol_priv.h` para tener acceso a la estrucutra, constructor y destructor. Pero no se incluye en el `main.c`.
|-

| 11.4
| Objetos II: ...
|-

| ...
| ...
| ...

|}

Material

2019-06-10T14:59:38Z

Carfalgar: /* Vídeos */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)
* [https://en.cppreference.com/w/c Documentación de C]
* [[:Archivo:Autotools.zip | Plantilla autotools]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)
# https://youtu.be/sq14oKSodPM
# https://youtu.be/JHUozE_4HPs
# https://youtu.be/cVDUGO0_saE

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-r[<seed>]]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 9
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.2
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| 10
|
| Configura compilación con autotools
* Se mueve todo el código a una nueva carpeta `src/`
* Se crean los archivos necesarios para configurar autotools:
** `autogen.sh`
** `configure.ac`
** `makefile.am`
* Se elimina el `makefile` ya que este será generado por autotools
* Se añaden al `.gitignore` todos los archivos autogenerados de autotools
|-

| rowspan="4" | 11
| 11.1
| Objetos II: Implementar el objeto `gol_toroid` hijo de `gol`
En esta primera versión, se implementa una herencia usando punteros a funciones.

* El objeto `gol` contiene dos atributos nuevos, punteros a las funciones que implementarán la funcionalidad de `get_cell()` y `set_cell()`
* Los métodos estáticos `get_cell()` y `set_cell()` de `gol.c` simplemente llaman a los punteros a funciones del objeto.
* Se crea el objeto nuevo en dos archivos: `gol_toroid.c` y `gol_toroid.h`
* La interfaz de este objeto (funciones en `gol_toroid.h`) sólo añade dos métodos: un constructor y un destructor, `gol_toroid_alloc()` y `gol_toroid_free()`)
* En `gol_toroid.c` se implementan este constructor y este destructor, además de las funciones estáticas `get_cell()` y `set_cell()` cuyas direcciones se asignan a los punteros a funcion.
* Las funciones estáticas `get_cell()` y `set_cell()` de `gol_toroid.c` implementan un acceso toroidal al mundo
* Como en `gol_toroid.c` se necesita acceso a la estructura y a los métodos `gol_alloc()` y `gol_free()`, se vuelven a pasar a `gol.h`.
* Se modifica `mem_test` para que haga uso de este nuevo objeto
|-

| 11.2
| Objetos II: Implementar un nuevo objeto `gol_finite`
* Se implementa el objeto `gol_finite` igual que se implementó `gol_toroid`
* Este objeto implementa un mundo con límites, a partir de los cuales todas las células se consideran muertas
* Se modifica el main para que `getopt` interprete un nuevo argumento que seleccionará el tipo de mundo a instanciar.
* Se modifica `mem_test` para que compruebe los dos mundos
|-

| 11.3
| Objetos II: Privatizar la estructura gol y algunos métodos
* Se crea una paraja de archivos `gol_priv.h` y `gol_priv.c` que albergan las definiciones de `struct gol` y de los métodos `gol_alloc()` y `gol_free()`
* El resto de objetos incluyen este `gol_priv.h` para tener acceso a la estrucutra, constructor y destructor. Pero no se incluye en el `main.c`.
|-

| 11.4
| Objetos II: ...
|-

| ...
| ...
| ...

|}

Material

2019-06-10T14:52:14Z

Carfalgar: /* Material de clase */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)
* [https://en.cppreference.com/w/c Documentación de C]
* [[:Archivo:Autotools.zip | Plantilla autotools]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)
# https://youtu.be/sq14oKSodPM
# https://youtu.be/JHUozE_4HPs

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-r[<seed>]]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 9
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.2
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| 10
|
| Configura compilación con autotools
* Se mueve todo el código a una nueva carpeta `src/`
* Se crean los archivos necesarios para configurar autotools:
** `autogen.sh`
** `configure.ac`
** `makefile.am`
* Se elimina el `makefile` ya que este será generado por autotools
* Se añaden al `.gitignore` todos los archivos autogenerados de autotools
|-

| rowspan="4" | 11
| 11.1
| Objetos II: Implementar el objeto `gol_toroid` hijo de `gol`
En esta primera versión, se implementa una herencia usando punteros a funciones.

* El objeto `gol` contiene dos atributos nuevos, punteros a las funciones que implementarán la funcionalidad de `get_cell()` y `set_cell()`
* Los métodos estáticos `get_cell()` y `set_cell()` de `gol.c` simplemente llaman a los punteros a funciones del objeto.
* Se crea el objeto nuevo en dos archivos: `gol_toroid.c` y `gol_toroid.h`
* La interfaz de este objeto (funciones en `gol_toroid.h`) sólo añade dos métodos: un constructor y un destructor, `gol_toroid_alloc()` y `gol_toroid_free()`)
* En `gol_toroid.c` se implementan este constructor y este destructor, además de las funciones estáticas `get_cell()` y `set_cell()` cuyas direcciones se asignan a los punteros a funcion.
* Las funciones estáticas `get_cell()` y `set_cell()` de `gol_toroid.c` implementan un acceso toroidal al mundo
* Como en `gol_toroid.c` se necesita acceso a la estructura y a los métodos `gol_alloc()` y `gol_free()`, se vuelven a pasar a `gol.h`.
* Se modifica `mem_test` para que haga uso de este nuevo objeto
|-

| 11.2
| Objetos II: Implementar un nuevo objeto `gol_finite`
* Se implementa el objeto `gol_finite` igual que se implementó `gol_toroid`
* Este objeto implementa un mundo con límites, a partir de los cuales todas las células se consideran muertas
* Se modifica el main para que `getopt` interprete un nuevo argumento que seleccionará el tipo de mundo a instanciar.
* Se modifica `mem_test` para que compruebe los dos mundos
|-

| 11.3
| Objetos II: Privatizar la estructura gol y algunos métodos
* Se crea una paraja de archivos `gol_priv.h` y `gol_priv.c` que albergan las definiciones de `struct gol` y de los métodos `gol_alloc()` y `gol_free()`
* El resto de objetos incluyen este `gol_priv.h` para tener acceso a la estrucutra, constructor y destructor. Pero no se incluye en el `main.c`.
|-

| 11.4
| Objetos II: ...
|-

| ...
| ...
| ...

|}

Archivo:Autotools.zip

2019-06-10T14:52:00Z

Carfalgar:

Material

2019-06-10T14:49:28Z

Carfalgar: /* Tareas */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)
* [https://en.cppreference.com/w/c Documentación de C]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)
# https://youtu.be/sq14oKSodPM
# https://youtu.be/JHUozE_4HPs

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-r[<seed>]]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 9
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.2
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| 10
|
| Configura compilación con autotools
* Se mueve todo el código a una nueva carpeta `src/`
* Se crean los archivos necesarios para configurar autotools:
** `autogen.sh`
** `configure.ac`
** `makefile.am`
* Se elimina el `makefile` ya que este será generado por autotools
* Se añaden al `.gitignore` todos los archivos autogenerados de autotools
|-

| rowspan="4" | 11
| 11.1
| Objetos II: Implementar el objeto `gol_toroid` hijo de `gol`
En esta primera versión, se implementa una herencia usando punteros a funciones.

* El objeto `gol` contiene dos atributos nuevos, punteros a las funciones que implementarán la funcionalidad de `get_cell()` y `set_cell()`
* Los métodos estáticos `get_cell()` y `set_cell()` de `gol.c` simplemente llaman a los punteros a funciones del objeto.
* Se crea el objeto nuevo en dos archivos: `gol_toroid.c` y `gol_toroid.h`
* La interfaz de este objeto (funciones en `gol_toroid.h`) sólo añade dos métodos: un constructor y un destructor, `gol_toroid_alloc()` y `gol_toroid_free()`)
* En `gol_toroid.c` se implementan este constructor y este destructor, además de las funciones estáticas `get_cell()` y `set_cell()` cuyas direcciones se asignan a los punteros a funcion.
* Las funciones estáticas `get_cell()` y `set_cell()` de `gol_toroid.c` implementan un acceso toroidal al mundo
* Como en `gol_toroid.c` se necesita acceso a la estructura y a los métodos `gol_alloc()` y `gol_free()`, se vuelven a pasar a `gol.h`.
* Se modifica `mem_test` para que haga uso de este nuevo objeto
|-

| 11.2
| Objetos II: Implementar un nuevo objeto `gol_finite`
* Se implementa el objeto `gol_finite` igual que se implementó `gol_toroid`
* Este objeto implementa un mundo con límites, a partir de los cuales todas las células se consideran muertas
* Se modifica el main para que `getopt` interprete un nuevo argumento que seleccionará el tipo de mundo a instanciar.
* Se modifica `mem_test` para que compruebe los dos mundos
|-

| 11.3
| Objetos II: Privatizar la estructura gol y algunos métodos
* Se crea una paraja de archivos `gol_priv.h` y `gol_priv.c` que albergan las definiciones de `struct gol` y de los métodos `gol_alloc()` y `gol_free()`
* El resto de objetos incluyen este `gol_priv.h` para tener acceso a la estrucutra, constructor y destructor. Pero no se incluye en el `main.c`.
|-

| 11.4
| Objetos II: ...
|-

| ...
| ...
| ...

|}

Material

2019-06-05T15:04:30Z

Carfalgar: /* Vídeos */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)
* [https://en.cppreference.com/w/c Documentación de C]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)
# https://youtu.be/sq14oKSodPM
# https://youtu.be/JHUozE_4HPs

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-r[<seed>]]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 9
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.1
(opcional)
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| ...
| ...
| ...

|}

Material

2019-06-03T15:12:59Z

Carfalgar: /* Tareas */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)
* [https://en.cppreference.com/w/c Documentación de C]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)
# https://youtu.be/sq14oKSodPM

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-r[<seed>]]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 9
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.1
(opcional)
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| ...
| ...
| ...

|}

Material

2019-06-03T15:01:16Z

Carfalgar: /* Vídeos */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)
* [https://en.cppreference.com/w/c Documentación de C]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)
# https://youtu.be/sq14oKSodPM

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-r[<seed>]]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 8
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.1
(opcional)
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| ...
| ...
| ...

|}

Material

2019-06-03T14:38:21Z

Carfalgar: /* Material de clase */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)
* [https://en.cppreference.com/w/c Documentación de C]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-r[<seed>]]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 8
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.1
(opcional)
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| ...
| ...
| ...

|}

Archivo:Slides prin.pdf

2019-06-03T01:39:27Z

Carfalgar: Carfalgar subió una nueva versión de Archivo:Slides prin.pdf

Archivo:Transparencias.pdf

2019-06-03T01:39:10Z

Carfalgar: Carfalgar subió una nueva versión de Archivo:Transparencias.pdf

Material

2019-06-03T01:29:34Z

Carfalgar: /* Tareas */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-r[<seed>]]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 8
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.1
(opcional)
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| ...
| ...
| ...

|}

Material

2019-06-03T01:27:41Z

Carfalgar: /* Tareas */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]
* [https://github.com/profedotc/solucion Repositorio con la solución del trabajo de clase] (se irá actualizando)

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| rowspan="2" | 7
| 7.1
| Objetos: Reserva dinámica de memoria para la estructura `gol`
* Se cambia ligeramente la interfaz de la función `gol_alloc` para que devuelva un puntero a `struct gol` en lugar de recibirlo.
* Ahora se reservan dinámicamente dos bloques de memoria: uno para la estructura `struct gol` y otro para los arrays del mundo.
* La función `gol_free` debe liberar los dos bloques de memoria.
|-

| 7.2
| Objetos: Ocultar la estructura `gol`
Mediante una declaración adelantada de `struct gol` en `gol.h` conseguimos
ocultar los campos de nuestro objeto (privatizar) a los usuarios de la librería.
|-

| rowspan="2" | 8
| 8.1
| Utilizar getopt para recibir argumentos de línea de comandos
* El programa ahora recibe como argumentos el ancho y el alto del mundo, además de el argumento `-u, --usage` que imprime el siguiente mensaje de ayuda:
Usage: ./gol -w <width> -h <height>
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
* Es obligatorio especificar el tamaño del mundo, si no se especifica se imprime un mensaje de error y se termina el programa.
* Se define el tipo `struct gol_options` para guardar los parámetros de entrada: `int width`, `int height` y `bool usage`
* Se crean dos funciones estáticas que encapsulan la lógica de tratar los argumentos y de imprimir el mensaje de ayuda:
* `static bool parse_args(struct gol_options *gol_opt, int argc, char *argv[]);`
* `static void print_usage(const char *argv0);`
|-

| 8.2
| Implementar la opción de inicializar el mundo aleatoriamente
* Se añade un argumento opcional con un parámetro obligatorio. Indica el patrón de inicialización del mundo: "glider" o "random"
* Se añade otro argumento opcional con parámetro obligatorio. Proporcionará la semilla para `srand()`. Si no se pasa este parámetro, se toma como semilla el tiempo actual. Esta es ahora la salida de `./gol -u`:
Usage: ./gol -w <width> -h <height> [-r[<seed>]]
-u, --usage: Prints this help message
-w, --width: Width of the world
-h, --height: Height of the world
-s, --Seed [seed]: Seed for random world.
-p, --pattern [pattern]: Initialization pattern:
- glider
- random
* Se modifica el método `gol_init()` para recibir un enumerado, `enum gol_init_pattern`, que esta definido en `gol.h`. El método `gol_init()` llama a los métodos privados `gol_init_rand()` o `gol_init_glider()`, según el patrón de inicialización seleccionado.
* Se crea una función auxiliar en `main.c` que transforma del string recibido como argumento a el enumerado que acepta `gol_init()`
* Se modifica `mem_test.c` para adaptarlo al nuevo `gol_init()`
|-

| rowspan="2" | 8
| 9.1
| Cargar y guardar el mundo desde un archivo binario
* Implementar los métodos `gol_save()` y `gol_load()` para guardar y cargar el mundo desde un archivo binario. Estas funciones simplemente guardan el array tal cual en el archivo especificado y leen el archivo guardándolo en el array.
bool gol_load(struct gol *gol, const char *file);
bool gol_save(const struct gol *gol, const char *file);
* Modificar el main para que acepte los siguientes comandos, además de 'q' para cerrar:
* 'l': Si se pulsa este caracter, llamar a una función estática `load_world()` que pida al usuario que inserte el nombre de un archivo. Luego carga este archivo con la función `gol_load()`
* 's': Si se pulsa este caracter, llamar a una función estática `save_world()` que pida al usuario que inserte el nombre de un archivo. Luego guarda este archivo con la función `gol_save()`
* Si cualquiera de los nuevos comandos falla, se informa al usuario del error y se continua la ejecución. Para que el usuario pueda leer el mensaje de error se llama a `getchar()`, así se pausa la ejecución hasta que se pulse un caracter.
|-

| 9.1
| Guardar y cargar el mundo desde un archivo de texto
Modificar `gol_save()` y `gol_load()` para guardar y cargar el estado del
mundo en un formato de texto parecido al que se usa en `gol_print()`.

Ejemplo de archivo para mundo de 10x20:
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . # . . . . . . . . . . . . .
. . . . . . . # . . . . . . . . . . . .
. . . . . # # # . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
|-

| ...
| ...
| ...

|}

Material

2019-06-03T01:17:47Z

Carfalgar: /* Material de clase */

Material

2019-05-31T16:44:51Z

Carfalgar: /* Vídeos */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ (incompleto)

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| ...
| ...
| ...

|}

Material

2019-05-31T14:56:26Z

Carfalgar: /* Vídeos */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM
# No hay
# https://youtu.be/dk-0xF5pJpQ

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| ...
| ...
| ...

|}

Archivo:Transparencias.pdf

2019-05-28T20:24:27Z

Carfalgar: Carfalgar subió una nueva versión de Archivo:Transparencias.pdf

Archivo:Slides prin.pdf

2019-05-28T20:24:20Z

Carfalgar: Carfalgar subió una nueva versión de Archivo:Slides prin.pdf

Material

2019-05-27T14:43:09Z

Carfalgar: /* Vídeos */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA
# https://youtu.be/EhX3E8lLcUM

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| ...
| ...
| ...

|}

Material

2019-05-24T14:56:42Z

Carfalgar: /* Vídeos */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU
# https://youtu.be/1SJ_fEXD7OA

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| ...
| ...
| ...

|}

Material

2019-05-22T14:58:49Z

Carfalgar: /* Vídeos */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4
# https://youtu.be/57-zWEnGxHU

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| ...
| ...
| ...

|}

Material

2019-05-20T15:02:34Z

Carfalgar: /* Tareas */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Crear makefile y dividir el programa
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| ...
| ...
| ...

|}

Material

2019-05-20T14:52:34Z

Carfalgar: /* Vídeos */

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM
# https://youtu.be/IDfllYxE7I4

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| ...
| ...
| ...

|}

Material

2019-05-20T14:49:54Z

Carfalgar:

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Slides_prin.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| ...
| ...
| ...

|}

Material

2019-05-20T14:49:05Z

Carfalgar:

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:Transparencias_print.pdf|Transparencias para imprimir]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| ...
| ...
| ...

|}

Archivo:Slides prin.pdf

2019-05-20T14:48:54Z

Carfalgar:

Archivo:Transparencias.pdf

2019-05-20T14:46:38Z

Carfalgar: Carfalgar subió una nueva versión de Archivo:Transparencias.pdf

Página principal

2019-05-20T14:45:55Z

Carfalgar:

Bienvenid@ al wiki del IV Curso de programación en C.

Este curso ofrecerá una visión moderna de la programación en C, partiendo de los estándares de C99 y C11. Se realizará siempre un enfoque práctico. Es por ello que el curso introducirá al estudiante en el uso de las bibliotecas nativas en C de referencia para el desarrollo de software en entornos gráficos, red, importación/exportación de datos de ficheros. Consulta el [https://1984.lsi.us.es/curso-programacion-c/ contenido del curso].

= Matrícula y preinscripción =

* '''Preinscripción''': Si estás interesado debes realizar la preinscripción gratuita cuanto antes para reservar tu plaza.
* '''Matrícula''': El periodo de matrícula está comprendido entre los días '''1 y 7 de Abril''' (si quieres matricularte fuera de plazo contacta con nosotros) y tiene un coste total de '''180€'''

Puedes realizar tanto la matrícula como la preinscripción a través de esta web: https://cfp.us.es/cursos/fc/programacion-en-c/3831/

 ¡¡ATENCIÓN: Los créditos ECTS de este curso NO son convalidables!!

Los créditos de los cursos de formación continua tienen una validez meramente curricular y no pueden ser reconocidos para los planes de grado.

= Lugar =

El curso se impartirá en el edificio '''CRAI Antonio de Ulloa''', Avenida Reina Mercedes, s/n 41012 Sevilla. ([http://www.openstreetmap.org/way/27486919#map=19/37.35971/-5.98621 ver en mapa]). Se utilizará el aula TIC1, situada en la 2ª planta del edificio.

Todas las aulas disponen de ordenadores para los alumnos. Si desea llevar su portátil, puede hacerlo siempre que disponga de alguna distribución GNU/Linux (preferiblemente Ubuntu nativo o en máquina virtual).

= Fechas y horario =

El curso comprenderá entre los días '''2 de Mayo''' y '''14 de Junio'''. Las clases serán los '''Lunes''', '''Miércoles''' y '''Viernes''' de '''17:00 a 19:30''' (salvo excepción).
Para más información consultar: http://1984.lsi.us.es/curso-programacion-c/

[[File:horario.png|thumb|700px]]

= Lista de correo =
El curso se apoya en una [https://listas.us.es/mailman/listinfo/programacion-c lista de correo] que puedes emplear para plantear dudas y discusiones relacionadas con la programación en C.

= Criterios de evaluación =
El curso tendrá un enfoque muy práctico, por lo que la evaluación se basará en diversos ejercicios y trabajos realizados individualmente y repartidos a lo largo del curso.

= Profesores =
* '''Pablo Neira Ayuso''': pneira <AT> us <DOT> es
* '''Carlos Falgueras García''': carfalgar <AT> alum <DOT> us <DOT> es

= Contacto y más información =
Para más información puedes consultar la [https://cfp.us.es/cursos/fc/programacion-en-c/3831/ web del Centro de Formación Permanente] o contactar por email: '''carfalgar <AT> alum <DOT> us <DOT> es'''

= Material y tareas =
[[Material]]

Material

2019-05-19T19:26:46Z

Carfalgar:

== Material de clase ==

* [[:Archivo:Transparencias.pdf|Transparencias]] (Se irá actualizando)
* [[:Archivo:plantilla_gol.c|Plantilla Juego de la vida]]

== Vídeos ==

# https://youtu.be/C0UiG1uYgYQ
# https://youtu.be/gqzYwGdPfYM

== Tareas ==

{| class="wikitable"
! Tarea
! Subtarea
! Descripción
|-
| 1
|
| Versión inicial
* Completada la plantilla del juego de la vida
* Completado README.md
|-

| rowspan="2" | 2
| 2.1
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| 2.2
| Intercambiar mundos en lugar de copiarlos
* 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
|-

| rowspan="2" | 3
| 3.1
| Encapsular el juego de la vida en una estructura
* 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`
|-

| 3.2
| Ocultar todas las funciones que el usuario no necesite
* Se ocultan `gol_get_cell` y `gol_count_neighbours`
* Se declaran como `static` y se elimina el prefijo `gol_`
|-

| rowspan="2" | 4
| 4.1
| Memoria dinámica I: Añadir objetivos `debug` y `release`
Se añaden dos nuevos objetivos al makefile que modifican los flags de gcc para
crear dos ejecutables distintos según convenga.
|-

| 4.2
| Memoria dinámica I: Reserva dinámica de memoria para el mundo
* 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
|-

| rowspan="2" | 5
| 5.1
| Memoria dinámica II: Implementar test de memoria
* 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
|-

| 5.2
| Memoria dinámica II: Una sola reserva de memoria por mundo
* 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
|-

| rowspan="2" | 6
| 6.1
| Memoria dinámica III: Macro funcional para acceder a las células
Utilizar una macro para reutilizar y evitar repetir el mismo código en
`get_cell` y `set_cell`
|-

| 6.2
| Memoria dinámica III: Una reserva de memoria para los dos mundos
* 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.
|-

| ...
| ...
| ...

|}

Página principal

2019-05-06T04:48:00Z

Carfalgar:

Material

2019-05-06T04:46:35Z

Carfalgar: Página creada con « == Material de clase == * Transparencias (Se irá actualizando) * Plantilla Juego de la vida == Vídeos ==...»

Archivo:Plantilla gol.c

2019-05-06T04:45:52Z

Carfalgar:

Archivo:Transparencias.pdf

2019-05-06T04:43:08Z

Carfalgar:

Página principal

2019-03-27T17:28:29Z

Carfalgar: /* Fechas y horario */

Página principal

2019-03-21T07:56:48Z

Carfalgar: /* Fechas y horario */

Bienvenid@ al wiki del IV Curso de programación en C.

Este curso ofrecerá una visión moderna de la programación en C, partiendo de los estándares de C99 y C11. Se realizará siempre un enfoque práctico. Es por ello que el curso introducirá al estudiante en el uso de las bibliotecas nativas en C de referencia para el desarrollo de software en entornos gráficos, red, importación/exportación de datos de ficheros. Consulta el [https://1984.lsi.us.es/curso-programacion-c/ contenido del curso].

= Matrícula y preinscripción =

* '''Preinscripción''': Si estás interesado debes realizar la preinscripción gratuita cuanto antes para reservar tu plaza.
* '''Matrícula''': El periodo de matrícula está comprendido entre los días '''1 y 7 de Abril''' (si quieres matricularte fuera de plazo contacta con nosotros) y tiene un coste total de '''180€'''

Puedes realizar tanto la matrícula como la preinscripción a través de esta web: https://cfp.us.es/cursos/fc/programacion-en-c/3831/

 ¡¡ATENCIÓN: Los créditos ECTS de este curso NO son convalidables!!

Los créditos de los cursos de formación continua tienen una validez meramente curricular y no pueden ser reconocidos para los planes de grado.

= Lugar =

El curso se impartirá en el edificio '''CRAI Antonio de Ulloa''', Avenida Reina Mercedes, s/n 41012 Sevilla. ([http://www.openstreetmap.org/way/27486919#map=19/37.35971/-5.98621 ver en mapa]). Se utilizará el aula TIC1, situada en la 2ª planta del edificio.

Todas las aulas disponen de ordenadores para los alumnos. Si desea llevar su portátil, puede hacerlo siempre que disponga de alguna distribución GNU/Linux (preferiblemente Ubuntu nativo o en máquina virtual).

= Fechas y horario =

El curso comprenderá entre los días '''2 de Mayo''' y '''14 de Junio'''. Las clases serán los '''Lunes''', '''Miércoles''' y '''Viernes''' de '''17:00 a 19:30''' (salvo excepción).
Para más información consultar: https://1984.lsi.us.es/curso-programacion-c/

[[File:horario.png|thumb|700px]]

= Lista de correo =
El curso se apoya en una [https://listas.us.es/mailman/listinfo/programacion-c lista de correo] que puedes emplear para plantear dudas y discusiones relacionadas con la programación en C.

= Criterios de evaluación =
El curso tendrá un enfoque muy práctico, por lo que la evaluación se basará en diversos ejercicios y trabajos realizados individualmente y repartidos a lo largo del curso.

= Profesores =
* '''Pablo Neira Ayuso''': pneira <AT> us <DOT> es
* '''Carlos Falgueras García''': carfalgar <AT> alum <DOT> us <DOT> es

= Contacto y más información =
Para más información puedes consultar la [https://cfp.us.es/cursos/fc/programacion-en-c/3831/ web del Centro de Formación Permanente] o contactar por email: '''carfalgar <AT> alum <DOT> us <DOT> es'''

Página principal

2019-03-21T07:56:37Z

Carfalgar: /* Fechas y horario */

Bienvenid@ al wiki del IV Curso de programación en C.

Este curso ofrecerá una visión moderna de la programación en C, partiendo de los estándares de C99 y C11. Se realizará siempre un enfoque práctico. Es por ello que el curso introducirá al estudiante en el uso de las bibliotecas nativas en C de referencia para el desarrollo de software en entornos gráficos, red, importación/exportación de datos de ficheros. Consulta el [https://1984.lsi.us.es/curso-programacion-c/ contenido del curso].

= Matrícula y preinscripción =

* '''Preinscripción''': Si estás interesado debes realizar la preinscripción gratuita cuanto antes para reservar tu plaza.
* '''Matrícula''': El periodo de matrícula está comprendido entre los días '''1 y 7 de Abril''' (si quieres matricularte fuera de plazo contacta con nosotros) y tiene un coste total de '''180€'''

Puedes realizar tanto la matrícula como la preinscripción a través de esta web: https://cfp.us.es/cursos/fc/programacion-en-c/3831/

 ¡¡ATENCIÓN: Los créditos ECTS de este curso NO son convalidables!!

Los créditos de los cursos de formación continua tienen una validez meramente curricular y no pueden ser reconocidos para los planes de grado.

= Lugar =

El curso se impartirá en el edificio '''CRAI Antonio de Ulloa''', Avenida Reina Mercedes, s/n 41012 Sevilla. ([http://www.openstreetmap.org/way/27486919#map=19/37.35971/-5.98621 ver en mapa]). Se utilizará el aula TIC1, situada en la 2ª planta del edificio.

Todas las aulas disponen de ordenadores para los alumnos. Si desea llevar su portátil, puede hacerlo siempre que disponga de alguna distribución GNU/Linux (preferiblemente Ubuntu nativo o en máquina virtual).

= Fechas y horario =

El curso comprenderá entre los días '''2 de Mayo''' y '''12 de Junio'''. Las clases serán los '''Lunes''', '''Miércoles''' y '''Viernes''' de '''17:00 a 19:30''' (salvo excepción).
Para más información consultar: https://1984.lsi.us.es/curso-programacion-c/

[[File:horario.png|thumb|700px]]

= Lista de correo =
El curso se apoya en una [https://listas.us.es/mailman/listinfo/programacion-c lista de correo] que puedes emplear para plantear dudas y discusiones relacionadas con la programación en C.

= Criterios de evaluación =
El curso tendrá un enfoque muy práctico, por lo que la evaluación se basará en diversos ejercicios y trabajos realizados individualmente y repartidos a lo largo del curso.

= Profesores =
* '''Pablo Neira Ayuso''': pneira <AT> us <DOT> es
* '''Carlos Falgueras García''': carfalgar <AT> alum <DOT> us <DOT> es

= Contacto y más información =
Para más información puedes consultar la [https://cfp.us.es/cursos/fc/programacion-en-c/3831/ web del Centro de Formación Permanente] o contactar por email: '''carfalgar <AT> alum <DOT> us <DOT> es'''

Archivo:Horario.png

2019-03-21T07:53:21Z

Carfalgar:

Archivo:Deleteme.svg

2019-03-21T07:53:11Z

Carfalgar: Carfalgar trasladó la página Archivo:Horario.svg a Archivo:Deleteme.svg

Archivo:Horario.svg

2019-03-21T07:53:11Z

Carfalgar: Carfalgar trasladó la página Archivo:Horario.svg a Archivo:Deleteme.svg

#REDIRECCIÓN [[Archivo:Deleteme.svg]]

Página principal

2019-03-05T19:01:30Z

Carfalgar:

Bienvenid@ al wiki del IV Curso de programación en C.

Este curso ofrecerá una visión moderna de la programación en C, partiendo de los estándares de C99 y C11. Se realizará siempre un enfoque práctico. Es por ello que el curso introducirá al estudiante en el uso de las bibliotecas nativas en C de referencia para el desarrollo de software en entornos gráficos, red, importación/exportación de datos de ficheros. Consulta el [https://1984.lsi.us.es/curso-programacion-c/ contenido del curso].

= Matrícula y preinscripción =

* '''Preinscripción''': Si estás interesado debes realizar la preinscripción gratuita cuanto antes para reservar tu plaza.
* '''Matrícula''': El periodo de matrícula está comprendido entre los días '''1 y 7 de Abril''' (si quieres matricularte fuera de plazo contacta con nosotros) y tiene un coste total de '''180€'''

Puedes realizar tanto la matrícula como la preinscripción a través de esta web: https://cfp.us.es/cursos/fc/programacion-en-c/3831/

 ¡¡ATENCIÓN: Los créditos ECTS de este curso NO son convalidables!!

Los créditos de los cursos de formación continua tienen una validez meramente curricular y no pueden ser reconocidos para los planes de grado.

= Lugar =

El curso se impartirá en el edificio '''CRAI Antonio de Ulloa''', Avenida Reina Mercedes, s/n 41012 Sevilla. ([http://www.openstreetmap.org/way/27486919#map=19/37.35971/-5.98621 ver en mapa]). Se utilizará el aula TIC1, situada en la 2ª planta del edificio.

Todas las aulas disponen de ordenadores para los alumnos. Si desea llevar su portátil, puede hacerlo siempre que disponga de alguna distribución GNU/Linux (preferiblemente Ubuntu nativo o en máquina virtual).

= Fechas y horario =

El curso comprenderá entre los días '''2 de Mayo''' y '''12 de Junio'''. Las clases serán los '''Lunes''', '''Miércoles''' y '''Viernes''' de '''17:00 a 19:30''' (salvo excepción).
Para más información consultar: https://1984.lsi.us.es/curso-programacion-c/

= Lista de correo =
El curso se apoya en una [https://listas.us.es/mailman/listinfo/programacion-c lista de correo] que puedes emplear para plantear dudas y discusiones relacionadas con la programación en C.

= Criterios de evaluación =
El curso tendrá un enfoque muy práctico, por lo que la evaluación se basará en diversos ejercicios y trabajos realizados individualmente y repartidos a lo largo del curso.

= Profesores =
* '''Pablo Neira Ayuso''': pneira <AT> us <DOT> es
* '''Carlos Falgueras García''': carfalgar <AT> alum <DOT> us <DOT> es

= Contacto y más información =
Para más información puedes consultar la [https://cfp.us.es/cursos/fc/programacion-en-c/3831/ web del Centro de Formación Permanente] o contactar por email: '''carfalgar <AT> alum <DOT> us <DOT> es'''

Archivo:Deleteme.svg

2019-03-05T18:55:45Z

Carfalgar:

Página principal

2018-02-28T12:00:50Z

Carfalgar: Actualización a IV edición

Bienvenid@ al wiki del IV Curso de programación en C.

Este curso ofrecerá una visión moderna de la programación en C, partiendo de los estándares de C99 y C11. Se realizará siempre un enfoque práctico. Es por ello que el curso introducirá al estudiante en el uso de las bibliotecas nativas en C de referencia para el desarrollo de software en entornos gráficos, red, importación/exportación de datos de ficheros y bases de datos. Consulta el [[contenido del curso]].

= Matrícula y preinscripción =

* '''Preinscripción''': Si estás interesado debes realizar la preinscripción gratuita cuanto antes para reservar tu plaza.
* '''Matrícula''': El periodo de matrícula está comprendido entre los días '''1 de Marzo y 8 de Marzo''' (si quieres matricularte fuera de plazo contacta con nosotros) y tiene un coste total de '''180€'''

Puedes realizar tanto la matrícula como la preinscripción a través de esta web: http://www.cfp.us.es/cursos/fc/programacion-en-c-moderno/3240/

 ¡¡ATENCIÓN: Los créditos ECTS de este curso NO son convalidables!!

Los créditos de los cursos de formación continua tienen una validez meramente curricular y no pueden ser reconocidos para los planes de grado.

= Lugar =

[[Archivo:Map.png | thumb | 500px]]

El curso se impartirá en el edificio '''CRAI Antonio de Ulloa''', Avenida Reina Mercedes, s/n 41012 Sevilla. ([http://www.openstreetmap.org/way/27486919#map=19/37.35971/-5.98621 ver en mapa]). Se utilizará el aula TIC5, situada en la 3ª planta del edificio.

Todas las aulas disponen de ordenadores para los alumnos. Si desea llevar su portátil, puede hacerlo siempre que disponga de alguna distribución GNU/Linux (preferiblemente Ubuntu nativo o en máquina virtual).

= Fechas y horario =

El curso comprenderá entre los días '''3 de Abril''' y '''22 de Mayo'''. Las clases serán los '''Martes''' y '''Jueves''' de '''17:00 a 19:30'''. Para saber en qué aula es cada clase ver [[Horario | Horario desglosado]].

= Lista de correo =
El curso se apoya en una [https://listas.us.es/mailman/listinfo/programacion-c lista de correo] temática disponible en [https://listas.us.es/mailman/listinfo/programacion-c] que puedes emplear para plantear dudas y discusiones relacionadas con la programación en C.

= Criterios de evaluación =
El curso tendrá un enfoque muy práctico, por lo que la evaluación se basará en diversos ejercicios y trabajos realizados individualmente y repartidos a lo largo del curso.

= Profesores =
* '''Pablo Neira Ayuso''': pneira <AT> us <DOT> es
* '''Carlos Falgueras García''': carfalgar <AT> alum <DOT> us <DOT> es

= Contacto y más información =
Para más información puedes consultar la [http://www.cfp.us.es/cursos/fc/programacion-en-c-moderno/3013/ web del Centro de Formación Permanente] o contactar por email: '''carfalgar <AT> alum <DOT> us <DOT> es'''

Discusión:Página principal

2018-02-28T11:56:53Z

Carfalgar: /* Material */

= Material =
* [[Temas, transparencias y anexos]]
* [[Tareas]]
* [[Extras]]
* [https://goo.gl/forms/YFYJOT2nbP4dSrei1 Encuesta]

= Ediciones anteriores =

* [[I Curso de programación en C moderno]]
* [[II Curso de programación en C moderno]]

Discusión:Página principal

2018-02-28T11:56:22Z

Carfalgar: Página creada con « = Material = * Temas, transparencias y anexos * Tareas * Extras * [https://goo.gl/forms/YFYJOT2nbP4dSrei1 Encuesta]»

= Material =
* [[Temas, transparencias y anexos]]
* [[Tareas]]
* [[Extras]]
* [https://goo.gl/forms/YFYJOT2nbP4dSrei1 Encuesta]

Página principal

2017-05-24T00:58:13Z

Carfalgar: /* Material */

[[Archivo:banner.png | 1000px]]

Bienvenid@ al wiki del II Curso de programación en C.

Este curso ofrecerá una visión moderna de la programación en C, partiendo de los estándares de C99 y C11. Se realizará siempre un enfoque práctico. Es por ello que el curso introducirá al estudiante en el uso de las bibliotecas nativas en C de referencia para el desarrollo de software en entornos gráficos, red, importación/exportación de datos de ficheros y bases de datos. Consulta el [[contenido del curso]].

= Matrícula y preinscripción =

* '''Preinscripción''': Si estás interesado debes realizar la preinscripción gratuita cuanto antes para reservar tu plaza.
* '''Matrícula''': El periodo de matrícula está comprendido entre los días '''1 de Marzo y 19 de Marzo''' (si quieres matricularte fuera de plazo contacta con nosotros) y tiene un coste total de '''180€'''

Puedes realizar tanto la matrícula como la preinscripción a través de esta web: http://www.cfp.us.es/cursos/fc/programacion-en-c-moderno/3240/

 ¡¡ATENCIÓN: Los créditos ECTS de este curso NO son convalidables!! 

Los créditos de los cursos de formación continua tienen una validez meramente curricular y no pueden ser reconocidos para los planes de grado.

= Lugar =

[[Archivo:Map.png | thumb | 500px]]

El curso se impartirá en el edificio '''CRAI Antonio de Ulloa''', Avenida Reina Mercedes, s/n 41012 Sevilla. ([http://www.openstreetmap.org/way/27486919#map=19/37.35971/-5.98621 ver en mapa]). Se utilizarán las aulas '''TIC 1, TIC 3 y TIC 4''' (en la 2ª planta del edificio).

Todas las aulas disponen de ordenadores para los alumnos. Si desea llevar su portátil, puede hacerlo siempre que disponga de alguna distribución GNU/Linux.

= Fechas y horario =

El curso comprenderá entre los días '''3 de Abril''' y el '''10 de Mayo'''. Las clases serán los '''Lunes''' y '''Miércoles''' de '''17:00 a 19:30'''. Para saber en qué aula es cada clase ver [[Horario | Horario desglosado]].

= Material =
* [[Temas, transparencias y anexos]]
* [[Tareas]]
* [[Extras]]
* [https://goo.gl/forms/YFYJOT2nbP4dSrei1 Encuesta]

= Lista de correo =
El curso se apoya en una [https://listas.us.es/mailman/listinfo/programacion-c lista de correo] temática disponible en [https://listas.us.es/mailman/listinfo/programacion-c] que puedes emplear para plantear dudas y discusiones relacionadas con la programación en C.

= Criterios de evaluación =
El curso tendrá un enfoque muy práctico, por lo que la evaluación se basará en diversos ejercicios y trabajos realizados individualmente y repartidos a lo largo del curso.

= Profesores =
* '''Pablo Neira Ayuso''': pneira <AT> us <DOT> es
* '''Carlos Falgueras García''': carfalgar <AT> alum <DOT> us <DOT> es

= Contacto y más información =
Para más información puedes consultar la [http://www.cfp.us.es/cursos/fc/programacion-en-c-moderno/3013/ web del Centro de Formación Permanente] o contactar por email: '''carfalgar <AT> alum <DOT> us <DOT> es'''

= Ediciones anteriores =

* [[I Curso de programación en C moderno]]
* [[II Curso de programación en C moderno]]

Tareas

2017-05-24T00:46:13Z

Carfalgar:

== Tarea 1: Versión inicial del mundo ==

# Haz un fork del repositorio con tu nombre
# Clona tu repositorio
# Completa el esqueleto proporcionado para implementar una primera versión funcional del juego de la vida
# Sube los cambios al tu repositorio
# Haz un pull request
# Arregla las correcciones del profesor
# Sube las correcciones a tu repo
# ¿Has conseguido que te acepten el pull request?
## NO -> goto 6
## Sí -> ¡Enhorabuena! Ya has terminado la tarea 1

== Tarea 2: Código modular, estructuras y makefile ==

a) Divide tu programa en 3 fichero:
* <code>main.c</code> : Implementará el bucle principal del juego
* <code>gol.h</code> : Tendrá las declaraciones de las funciones relacionadas con el juego de la vida
* <code>gol.c</code> : Tendrá las definiciones de las funciones anteriores

b) Crea un <code>makefile</code> para gestionar la compilación y dependencias

== Tarea 3: Primera aproximación a objetos ==

1. Encapsula tu mundo en la siguiente estructura:
struct world {
bool w1[W_SIZE_X][W_SIZE_Y];
bool w2[W_SIZE_X][W_SIZE_Y];
};
2. Modifica tus funciones para que reciban un puntero a tu objeto. Añade el modificador <code>const</code> siempre que no sea necesario modificar el objeto

Tu <code>main.c</code> debería quedar más o menos así:
#include <stdio.h>
#include <stdlib.h>
#include "gol.h"

int main()
{
int i = 0;
struct world w;

world_init(&w);
do {
printf("\033cIteration %d\n", i++);
world_print(&w);
world_step(&w);
} while (getchar() != 'q');

return EXIT_SUCCESS;
}

== Tarea 4: Objetos: Reserva dinámica de memoria ==
==== Interfaz pública ====
<code>gol.h</code>

struct world;

struct world *world_alloc(int size_x, int size_y);
void world_free(struct world *w);

void world_print(const struct world *w);
void world_iterate(struct world *w);

* <code>world_alloc</code>: Reserva en memoria e inicializa nuestro objeto <code>struct world</code>. Esto implica reservar memoria para la estrucutra y para los dos arrays que tiene dentro.
* <code>world_free</code>: Libera la memoria que ocupa nuestro objeto. Esto implica liberar primero la memoria de los arrays que tiene dentro la estrucutra, y luego la propia estructura.
* <code>world_print</code>: Imprime el mundo
* <code>world_iterate</code>: Realiza una iteración del juego de la vida

==== Implementación (privada) ====
<code>gol.c</code>

struct world
{
bool *cells[2];
int size_x;
int size_y;
};

static void fix_coords(const struct world *w, int *x, int *y);
static bool get_cell(const struct world *w, int x, int y);
static void set_cell(struct world *w, int buf, int x, int y, bool val);
static int count_neighbors(const struct world *w, int x, int y);

/* ... */
/* Definiciones de funciones privadas y públicas */
/* ... */

* <code>fix_coords</code>: Recibe unas coordenadas (x,y) y las modifica para implementar un mundo toroidal
* <code>get_cell</code>: Devuelve la célula en la posición (x,y), arreglando las coordenadas.
* <code>set_cell</code>: Cambia el valor de la célula de la posición (x,y), arreglando las coordenadas.
* <code>count_neighbors</code>: Cuenta las células vecinas '''haciendo uso de''' la función <code>get_cell</code>

==== NOTAS ====
* No olvides comprobar que has podido realizar correctamente la reserva de memoria:

En <code>world_alloc()</code>:
w = (struct world *)malloc(sizeof(struct world));
if (!w)
return NULL;

En <code>main()</code>:
w = world_alloc(WORLD_X, WORLD_Y);
if (!w) {
perror("Can't allocate world");
exit(EXIT_FAILURE);
}

* Las funciones privadas se declaran como <code>static</code> y '''no''' aparecen el el .h
* Ahora debes calcular a mano el offset en el array para llegar a la célula (x,y) con la fórmula: <code>size_x*y + x</code>. Encapsula esta fórmula en las funciones <code>get_cell</code> y <code>set_cell</code>.

== Tarea 5: Argumentos y lectura de ficheros ==
Al final de esta tarea tu juego de la vida deberá poder configurarse tanto por '''paso de argumentos''' como mediante un '''archivo de configuración'''.
La ayuda del programa devolvería lo siguiente:
Usage: gol
[-h|--help]
[-x|--size_x <num>]
[-y|--size_y <num>]
[-i|--init <init_mode>]
[config_file]

Esta tarea '''se divide en 3 subtareas distintas''' que deben corresponder con '''3 commits, uno por subtarea'''. La subtarea 3 es **opcional**.

=== Tarea 5.1: Objeto <code>struct config</code> ===
Completa la plantilla que encontrarás aquí: [[Archivo:Cfg template.tar]] para agrupar toda la lógica de configuración en un objeto.

Intégrala después en tu main de esta forma (debes modificar también <code>world_alloc</code>):

<syntaxhighlight lang="c" line="1" >
int main(int argc, char *argv[])
{
struct config config;
struct world * w;

if (!config_parse_argv(&config, argc, argv)) {
printf("ERROR\n");
config_print_usage(argv[0]);
return EXIT_FAILURE;
} else if (config.show_help){
config_print_usage(argv[0]);
return EXIT_SUCCESS;
}

w = world_alloc(&config);
if (!w) {
perror("Can't allocate world");
exit(EXIT_FAILURE);
}

do {
printf("\033cIteration %d\n", i++);
world_print(w);
world_iterate(w);
} while (getchar() != 'q');

world_free(w);
return EXIT_SUCCESS;
}
</syntaxhighlight>

De esta plantilla hay que destacar los siguientes puntos:

* Se define un objeto sencillo, público, sin reserva dinámica de memoria
* Se usa un enumerado para definir el tipo de inicialización con las siguientes peculiaridades:
** El primer elemento representa un modo no válido y forzamos su valor a -1
** El último elemento se usa para tener en una macro el número de elementos del enumerado. Por ello el nombre está entre barras bajas, para marcarlo como una opción no válida
** En el .c se define un array constante de cadenas, asociando cada cadena con su correspondiente valor en el enumerado. Se utiliza un inicializador un tanto particular, dónde inicializamos explicitamente los elementos del array mediante su índice: El índice se indica entre corchetes y se le asigna un valor con el operador igual: <code>[3] = 41</code>
** Se usa el array anterior para convertir el enumerado a una cadena, simplemente hay que acceder al array con el valor del enumerado como índice: <code>init_mode_str[CFG_GLIDER]</code>
* Se define una función privada <code>check_config</code> que agrupa la lógica de validación de argumentos. Devuelve false si los argumentos nos son válidos y true si lo son
* La función <code>str2init_mode</code> recibe una cadena y la va comparando una por una con las cadenas de modos de inicialización para ver con cual coincide. Si no coincide con ninguna devuelve <code>CFG_NOT_DEF</code> para indicar que no es un modo válido.

=== Tarea 5.2: Cargar fichero de configuración ===
Ahora has de permitir que tu programa lea la configuración de un archivo:

* El nombre del archivo ha de recibirse a través de los argumentos del programa, pero **no a través de un flag con getopt**. Ejemplo: <code>> gol config.txt</code>
* Las configuraciones del archivo tienen preferencia sobre los argumentos por consola
* El archivo de configuración constará de 3 líneas:
*# Ancho del mundo
*# Alto del mundo
*# Tipo de inicialización
Ejemplo <code>config.txt</code>:
20
15
glider
* Crea una función privada <code>static bool load_config(struct config *config);</code> que se encarge de abrir, parsear y cerrar el fichero. Devolverá cierto si todo ha ido bien y falso en caso contrario.
* La función <code>fgets</code> devuelve una cadena con un salto de línea (si lo hay). Vas a tener que quitárselo haciendo uso de la función [http://es.cppreference.com/w/c/string/byte/strchr strchr]
* Échale un ojo a este fragmento de código:

<syntaxhighlight lang="c" line="1" >
int config_parse_argv(struct config *config, int argc, char *argv[])
{
...

// Check for config file name
if (optind != argc) {
if (optind == argc - 1) {
config->cfg_file = argv[optind];
if (!load_config(config))
return false;
} else {
return false;
}
}

return check_config(config);
}
</syntaxhighlight>

* Y a este otro:
<syntaxhighlight lang="c" line="1" >
// Size x
char line[LINE_LEN];
fgets(line, LINE_LEN, file);
if (ferror(file)) {
perror("Error reading config file");
return false;
}
config->size_x = strtol(line, NULL, 0);
</syntaxhighlight>

=== Tarea 5.3 [opcional]: Guarda y carga de estado ===
Haz que tu juego de la vida guarde el estado del mundo antes de salir, en un archivo con el nombre que elijas. Haz también que este archivo se pueda cargar al lanzarlo de nuevo, para que comience por el mismo estado.

Notas:
* Has de crear dos nuevas opciones getopt para indicar el nombre del archivo a guardar y a cargar
* Para guardar el estado, haz un volcado directo en binario del array en un archivo. Utiliza la función [http://es.cppreference.com/w/c/io/fwrite fwrite] pasándole tu array y su tamaño. Ten en cuenta que debes guardar también las dimensiones de tu mundo.
* Para cargar el estado, haz una lectura directa del archivo binario con la función [http://es.cppreference.com/w/c/io/fread fread]. Puedes volcar el contenido del archivo directamente en el array de tu estructura, pero no olvides reservar la memoria primero (para esto debes leer antes las dimensiones de tu mundo)

== Tarea 6: Herencia ==

* Divide tu arquitectura en tres objetos:
** '''world''': Objeto '''abstracto''' que no tienen implementada las funciones <code>world_get_cell</code> y <code>world_set_cell</code>, pero sí el resto
** '''world_limited''': Objeto que hereda de ''world'' e implementa las funciones <code>world_get_cell</code> y <code>world_set_cell</code> de forma que se devuelva una célula muerta si los índices se salen del array y no haga nada en el caso del setter
** '''world_toroidal''': Objeto que hereda de ''world'' e implementa las funciones <code>world_get_cell</code> y <code>world_set_cell</code> para accedar al mundo de forma toroidal. Aquí además debes implementar la función <code>fix_coords</code> para usarla en tu getter y setter.

[[Archivo:Herencia.png | 1000px]]

'''NOTA''': Ejercicio de ejemplo resuelto: [[Archivo:Herencia res.tar]]

== Tarea 7: Listas ==
Modifica tu mundo para utilizar la doble estructura (array + lista) que se ha explicado en clase. Repasar [[:Archivo:Gol-list-new.pdf|descargar]]

* Debes modificar tus tres objetos (world, world_limited y world_toroidal), aunque la mayor parte de los cambios van en el objeto padre, mientras que en los hijos solo debes cambiar la forma en la que accedes al array (puesto que ahora habrá solo un array).
* Creamos un objeto nuevo, <code>struct cell</code>, muy sencillo y con todos sus atributos públicos. Este objeto será el elemento de nuestras listas.
* Ten en consideración las siguientes pistas y consulta esta plantilla: [[:Archivo:gol_list.tar]]

=== Estructura celula ===
Guarda un par de coordenadas para identificarla y facilitarnos el acceso al array
<syntaxhighlight lang="c" >
struct cell {
int x,y;
struct list_head lh;
};
</syntaxhighlight>

=== Estructura del objeto padre ===

<syntaxhighlight lang="c" >
struct world
{
bool *cells; // Observa que ahora solo necesitamos un array
int size_x;
int size_y;
// TODO: Crea las cabezas de lista (tipo `struct list_head`)
};
</syntaxhighlight>

=== Constructor objeto padre ===
* A la hora de reservar espacio para el array, lo hacemos solo una vez y guardamos la dirección en <code>w->cells</code>
* A la hora de inicializar nuestro array revivir cada célula en dos pasos:
*# Crear el nodo de lista (tipo <code>struct cell</code>) y comprobar que se ha realizado correctamente la reserva de memoria
*# Establecer a cierto la celula en el array
Esto lo podemos realizar a mano o creando una función auxiliar, digamos <code>add_initial_cell</code>

=== Función <code>count_neighbors</code> ===
Para facilitar la implementación de la nueva función <code>world_step</code>, os propongo esta mejora para contar vecionos.

# Creamos un array estático con las 8 sumas/restas que hay que aplicar a unas coordenadas (x,y) para obtener sus 8 vecinas
# Recorremos este array sumando estas diferencias para obtener las coordenadas de las células vecinas
# Usamos siempre nuestro método <code>get_cell</code> (implementado por los hijos) para que tenga en cuenta los límites del mundo

<syntaxhighlight lang="c" >
static const int neighbors_coords[8][2] = {
{-1, -1}, {0, -1}, {1, -1},
{-1, 0}, {1, 0},
{-1, 1}, {0, 1}, {1, 1}
};

static int count_neighbors(const struct world *w, int x, int y)
{
int count = 0;

for (int i=0; i < 8; i++)
count += get_cell(w,
x + neighbors_coords[i][0],
y + neighbors_coords[i][1]);

return count;
}
</syntaxhighlight>

=== Función <code>fix_coord</code> ===
Cambiamos el prototipo de esta función para que devuelva un booleano indicando si las coordenadas que ha recibido son validas o no. Esto nos hará falta posteriormente en la función <code>world_step</code>.
* En un mundo **toroidal** unas coordenadas fuera del mundo, ej <code>(-1, TAM_Y)</code>, serán corregidas, por lo <code>fix_coord</code> debe devolver siempre **cierto**
* En un mundo **limitado** unas coordenadas fuera del mundo, ej <code>(-1, TAM_Y)</code> son inválidas, por lo que <code>fix_coord</code> debe devolver **falso** en estos casos.

=== Función <code>world_step</code> ===
* Consultar la plantilla para tener una idea de cómo implementar esta función
* Fijaos que, cuado estamos comprobando las células vecinas, tenemos que tener especial cuidado con las que caen fuera de nuestro mundo:
*# En un mundo **toroidal** corregimos las coordenadas y aplicamos el algoritmo normal. Debemos corregirlas para no crear un nodo en nuestra lista con coordenadas inválidas.
*# En un mondo **limitado** no tiene sentido añadir a nuestra lista nodos con coordenadas fuera del array, puesto que estas células limítrofes siempre están muertas. Por ello, si <code>fix_coords</code> nos devuelve falso, no procesamos esa célula.

== Tarea 8: Iterfaz Gráfica ==
Implementa una interfaz gráfica para tu mundo con GTK. Sigue este código de ejemplo: [[:Archivo:gol_gui.tar]]

Archivo:Gol gui.tar

2017-05-24T00:46:05Z

Carfalgar: