Tareas - Historial de revisiones

Carfalgar en 00:46 24 may 2017

2017-05-24T00:46:13Z

Carfalgar en 22:17 23 may 2017

2017-05-23T22:17:53Z

Carfalgar: /* Tarea 6: Herencia */

2017-05-21T18:30:41Z

‎Tarea 6: Herencia

Carfalgar en 13:22 20 may 2017

2017-05-20T13:22:47Z

Carfalgar: /* Tarea 5: Argumentos y lectura de ficheros */

2017-05-14T23:23:51Z

‎Tarea 5: Argumentos y lectura de ficheros

Carfalgar: /* Tarea 5: Argumentos y lectura de ficheros */

2017-05-14T23:14:55Z

‎Tarea 5: Argumentos y lectura de ficheros

Carfalgar en 22:56 14 may 2017

2017-05-14T22:56:57Z

Carfalgar en 21:15 7 may 2017

2017-05-07T21:15:25Z

Carfalgar: /* Tarea 2: Estructurado, estructuras y makefile */

2017-04-24T18:40:33Z

‎Tarea 2: Estructurado, estructuras y makefile

Carfalgar: Página creada con «== 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 pri...»

2017-04-24T18:40:03Z

Página creada con «== 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 pri...»

Página nueva

== 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: Estructurado, 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;
}

← Revisión anterior		Revisión del 00:46 24 may 2017
Línea 312:		Línea 312:
	# 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 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.		# 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]]

← Revisión anterior		Revisión del 22:17 23 may 2017
Línea 238:		Línea 238:

	'''NOTA''': Ejercicio de ejemplo resuelto: [[Archivo:Herencia res.tar]]		'''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.

← Revisión anterior		Revisión del 18:30 21 may 2017
Línea 236:		Línea 236:

	[[Archivo:Herencia.png \| 1000px]]		[[Archivo:Herencia.png \| 1000px]]
		+
		+	'''NOTA''': Ejercicio de ejemplo resuelto: [[Archivo:Herencia res.tar]]

← Revisión anterior		Revisión del 13:22 20 may 2017
Línea 227:		Línea 227:
	* 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 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)		* 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]]

@@ Línea 121: / Línea 121: @@
-Esta tarea '''se divide en 3 subtareas distintas''' que deben corresponder con '''3 commits, uno por subtarea'''.
+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> ===
@@ Línea 219: / Línea 219: @@
 	config->size_x = strtol(line, NULL, 0);
 </syntaxhighlight>

@@ Línea 112: / Línea 112: @@
 == 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'''.
 Esta tarea '''se divide en 3 subtareas distintas''' que deben corresponder con '''3 commits, uno por subtarea'''.
 === 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>):
@@ Línea 160: / Línea 170: @@
 * 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.

← Revisión anterior		Revisión del 22:56 14 may 2017
Línea 109:		Línea 109:
	* Las funciones privadas se declaran como <code>static</code> y '''no''' aparecen el el .h		* 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>.		* 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'''.
		+	Esta tarea '''se divide en 3 subtareas distintas''' que deben corresponder con '''3 commits, uno por subtarea'''.
		+
		+	=== 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.

← Revisión anterior		Revisión del 21:15 7 may 2017
Línea 49:		Línea 49:
	return EXIT_SUCCESS;		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>.

@@ Línea 12: / Línea 12: @@
 ## Sí -> ¡Enhorabuena! Ya has terminado la tarea 1
-== Tarea 2: Estructurado, estructuras y makefile ==
+== Tarea 2: Código modular, estructuras y makefile ==
 a) Divide tu programa en 3 fichero: