Fe de erratas de la última charla

[Pablo Íñigo Blasco]

Bueno, ya se ha impartido la última charla del programa. Simplemente
agradecer a todos, por haber formado parte de esta iniciativa, con
gente así de trabajadora seguro que cambiaremos los tópicos que en
Andalucía y España no se trabaja. Se ha comentado que quizá algunos
compañeros estén interesados en recibir más charlas, en cuyo caso nos
gustaría que se debatiera en esta lista.

Por otra parte queremos comentar algunos errores que se han cometido
en la charla de hoy:
- el uso del malloc para el "struct punto" que se ha hecho al final se
hacía algo así:

*puntero=(char*) malloc(sizeof(p))
debe ser así:
puntero=(struct punto*) malloc(sizeof(struct punto))

Esto ha ocurrido porque hemos hecho explicaciones y modificaciones
sobre código ya hecho. Somos conscientes que algunos lo habéis copiado
como resultado final:

- Usar "*puntero" no es correcto porque malloc devuelve una dirección
a la zona de memoria donde se ubicarán nuestros datos (el SO nos da un
espacio válido donde trabajar sin colisionar con otros datos). Por lo
tanto esta dirección se debe almacenar en una variable de tipo "struct
punto*" es decir "puntero".

- El casting (char*) es incorrecto porque se está asignando un dato de
tipo (char*) a tipo (struct punto *), esto no es correcto por
diversas razones: la mas evidente, hemos reservado espacio para una
estructura punto, así que hacer un casting a char* no es lo que
queremos, otra razón es que los tipos de la parte izquierda y derecha
de la asignación son distintos, por lo que produciría un error de
compilación.

- Por último sizeof(p) puede ponerse sizeof(struct punto), en el
ejemplo que estuvimos viendo eran correctas ambos, cual elegir suele
decidirse según la claridad del código en el contexto en el que se
está trabajando, ciertamente para el malloc suele utilizarse el tipo
en lugar de una variable.

- Recordad que sizeof no es una función sino una palabra reservada del
lenguaje, el compilador en tiempo de compilación es consciente de
cuanto ocupa un tipo de dato y sustituye el sizeof por el número de
bytes que ocupa el tipo especificado entre paréntesis.

Por último, si, aunque parezca increíble se nos ha olvidado explicar
el free :-S. El espacio reservado dinámicamente (con malloc) hay que
liberarlo (no es como en Java donde tenemos un GC que va eliminando
los objetos que ya no se utilizan), para eso hay que utilizar la
función free:

Ejemplo:

struct punto* puntero=(struct punto*) malloc(sizeof(struct punto))

/*aquí iría el código de utilización de la estructura creada
dinámicamente*/

free(puntero);

Una variable no liberada ocupa espacio en memoria. Si reservamos mucho
espacio para variables de forma periódica sin liberarlo el tamaño en
memoria del proceso puede dispararse. Esto puede desembocar en un peor
rendimiento del programa o incluso que el SO mate al proceso "por
abusar". Por lo tanto se debe utilizar free siempre que haya un
malloc.

Saludos. Minolo y Pablo.