Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorio de docencia

Laboratorios de computación
salas A y B

Profesor: Tista Gacía Edgar M.I.

Asignatura: Estructuras de datos y algoritmos I

Grupo: 1

No de Práctica(s): 4

Integrante(s): Garrido Sánchez Samuel Arturo <418046193>

Semestre: 2018-2

Fecha de entrega: 12 de Marzo del 2018

Observaciones:

CALIFICACIÓN: __________
 Almacenamiento en tiempo de ejecución
Introducción
En el almacenamiento de todas las variables que maneja
un programa es indispensable tener una optimización del
espacio de la memoria, aunque en nuestras prácticas de
laboratorio es casi imposible llenar la memoria y llegar a
que la computadora crashee, en grandes programas que
requieran de una gran cantidad de memoria como es el
caso de las ediciones de contenido multimedia, puede lle-
gar a pasar.

Cuando un programa se ejecuta sobre un sistema operativo existe un proceso previo llamado carga-
dor que suministra al programa un bloque contiguo de memoria sobre el cual ha de ejecutarse. El
programa resultante de la compilación debe organizarse de forma que haga uso de este bloque. Para
ello el compilador incorpora al programa objeto el código necesario.

Las técnicas de gestión de la memoria durante la ejecución del programa difieren de unos lenguajes
a otros, e incluso de unos compiladores a otros.

Objetivo de la práctica:

• Utilizarás funciones en lenguaje C que permiten reservar y almacenar información de ma-

nera dinámica (en tiempo de ejecución).

Actividades:

• Utilizar funciones para reservar memoria dinámica en lenguaje C.


• Almacenar información en los elementos reservados con memoria dinámica.

1
 Teoría:
Memoria dinámica
La memoria dinámica que se almacena en el heap es aquella que se uti-
liza para almacenar datos que se crean en el medio de la ejecución de
un programa. En general, este tipo de datos puede llegar a ser casi la to-
talidad de los datos de un programa. Por ejemplo, supóngase un pro-
grama que abre un fichero y lee una colección de palabras. ¿Cuántas pa-
labras y de qué tamaño hay en el fichero? Hasta que no se procese el fi-
chero en su totalidad, no es posible saberlo.

La manipulación de memoria en C se hace con un mecanismo muy sim-

ple, pero a la vez muy propenso a errores. Los dos tipos de operaciones
son la petición y liberación de memoria. El ciclo es sencillo, cuando se
precisa almacenar un nuevo dato, se solicita tanta memoria en bytes
como sea necesaria, y una vez que ese dato ya no se necesita la memo-
ria se devuelve para poder ser reutilizada. Este esquema se conoce
como “gestión explícita de memoria” pues requiere ejecutar una opera-
ción para pedir la memoria y otra para liberarla.

Las cuatro operaciones principales para gestionar memoria en C son:

• void *malloc(size_t size). Es la función para reservar tantos bytes consecutivos de me-
moria como indica su único parámetro. De-
vuelve la dirección de memoria de la porción
reservada. La memoria no se inicializa a nin-
gún valor.
• void *calloc(size_t nmemb,
size_t size). Reserva espacio para tan-
tos elementos como indica su primer paráme-
tro nmemb, y cada uno de ellos con un tamaño
en bytes como indica el segundo. En otras pa-
labras, reserva nmemb * size bytes conse-
cutivos en memoria. Al igual que la función
anterior devuelve la dirección de memoria al comienzo del bloque reservado. Esta función inicializa
todos los bytes de la zona reservada al valor cero.
• void free(void *ptr). Función que, dado un puntero, libera el espacio previamente reser-
vado. El puntero que recibe como parámetro esta función tiene que ser el que se ha obtenido con una
llamada de reserva de memoria. No es necesario incluir el tamaño. Una vez que se ejecuta esta lla-
mada, los datos en esa porción de memoria se consideran basura, y por tanto pueden ser reutilizados
por el sistema.
• void *realloc(void *ptr, size_t size). Función para redimensionar una porción
de memoria previamente reservada a la que apunta el primer parámetro al tamaño dado como se-
gundo parámetro. La función devuelve la dirección de memoria de esta nueva porción redimensio-
nada, que no tiene por qué ser necesariamente igual al que se ha pasado como parámetro. Los datos
se conservan intactos en tantos bytes como el mínimo entre el tamaño antiguo y el nuevo.

2
Ejercicios propuestos:

1) Con basura: MALLOC

El ejercicio propuesto por la división se en-

carga de imprimir un arreglo mediante las fun-
ciones reservadas para la memoria dinámica
que resultará en un vector de tamaño definido
hasta el momento de la ejecución, depen-
diendo qué desee asignar el usuario. No es un
arreglo como tal ya que sería declarado como
array[];pero el tamaño asignado por medio de
la dirección de memoria que apunta: *arreglo podemos convertirlo en tal, la ventaja que ofrece éste método
a un arreglo convencional es que podemos liberar la cantidad de memoria que ocupa luego de que ya no sea
útil para la ejecución, por lo que resulta conveniente a la hora de elaborar programas más complejos de ma-
nera que esté optimizado para la mayoría de equipos. Hay un pequeño detalle con la función MALLOC a la
hora de asignar los espacios de memoria a la ejecución y es que se trae los espacios de memoria con todo y
basura incluida (no está vacío el espacio, se encuentra ocupado por otros elementos que se quedaron en la
memoria). He aquí la ejecución con algunos valores extraños y resulta ser la basura acumulada en los espa-
cios de memoria asignados.

Comentario: Creo que debieron hacer más acerca del vector creado ya que se libera al mismo tiempo que
se termina la ejecución, por lo que gráficamente no se nota la diferencia entre un arreglo y una variable
dinámica. Tal vez insertar datos al vector y mostrarlos, liberar la memoria y luego mostrarlo nuevamente
como vacío.

3
 2) Sin basura: CALLOC
Como se ha hablado en el ejercicio anterior, las variables dinámicas ofrecen hacer arreglos de manera que al
final de la ejecución sea liberada la memoria que
ocupó la variable. Pues hasta ahora todo bien
pero el detalle que se estipuló en MALLOC que
trae consigo la basura que contenga las direccio-
nes de memoria pues era un inconveniente. La
función CALLOC termina con el inconveniente
anterior, vaciando el contenido de la memoria
asignada y volviéndolo valor NULO (0 en C). El
ejercicio es similar al anterior con la única ex-
cepción de utilizar CALLOC al momento de
asignar la cantidad de memoria, por lo que imprimirá un vector de tamaño asignado por el usuario y mos-
trará los elementos nulos (0) en el vector, ya que habrá limpiado si contenido.

1) REALLOC para cambio de tamaño ya ejecutando el programa.

La función REALLOC permite el cambio
del tamaño de la variable dinámica una vez
que ha sido ejecutado el programa. Aquí pri-
mero se manda a llamar a la función MA-
LLOC de la cual se va insertando sobre la di-
rección de memoria asignada un elemento
que el usuario decida (la basura pues es re-
emplazada por el contenido que inserte el
usuario). Inmediatamente imprime el conte-
nido del vector, pero al terminar imprime un
mensaje que aumentará el tamaño el vector
al doble de lo que le habíamos asignado al
principio con la variable num mediante la
instrucción: num*= 2. Luego entra
REALLOC que básicamente cambia el tamaño que tenía el vector “arreglo” al nuevo valor de num, que es
el doble del original. Luego de que nuevamente le pide al usuario los valores para llegar a llenar el doble de
los valores de la nueva variable, imprime todo el vector (con los valores de num original y num doble) y fi-
nalmente libera la memoria que ocupa la variable arreglo para luego terminar con la ejecución.

4
 Ejercicios en clase

Ejercicio 1

Codifica, compila y ejecuta el código “ejercicio1” posteriormente responde las preguntas.

Análisis

a) Explica resultados

En la ejecución podemos notar que nos imprime diversas cosas pero en

realidad todo se entiende a ver las variables. Primero lo que vemos es
la impresión 2 veces del arreglo que contiene a 100, 200, 300, 400, 500
(lo imprime 2 veces por la siguiente línea):

for(cont=0;cont<5;cont++){

printf("arreglo[%d]=%d,arreglo[%d]=%d\n",

cont,arreglo[cont],cont,arreglo[cont]);

} //lo imprime 2 veces, ¿por qué?

Luego de entramos al apartado de las funciones de memoria dinámica.

En este apartado podemos ver que se manda a llamar MALLOC para

que por medio del apuntador *ptr y *ptr2 podamos hacer uso del ta-
maño que tenga el entero y el char que mandemos a llamar cuando lo
ejecutemos e inmediatamente multiplicara dicho valor por 5 y por 100
respectivamente. Nótese que el apuntador para la impresión del medio
estamos imprimiendo la dirección de memoria de ptr + cont que llega a
5 y luego lo que contiene, que por ser llamado por MALLOC trae ba-
sura consigo.

Luego para insertar elementos en ptr2 llamamos a strcpy para que acomode cada una de las letras de “Hola
amigo como estás” en el espacio reservado a ptr2, pero como el contador llega hasta 100 nos imprime 100

5
espacios. Con las direcciones de memoria de ptr2. Finalmente, en las impresiones de ptr2 nos indica las di-
recciones de memoria seguidas de contador y próximo nos muestra en contenido
de ptr2, que fue llenado con el mensaje.

b) Si removemos las líneas de 15 a 22.

En las líneas de la 15 a la 18 podemos ver que se le asigna al apuntador

*(ptr+cont) los valores del contador del ciclo que lo encierra que daría los valo-
res del 1 al 5, por lo que multiplicado por 100 nos arrojaría los números: 100,
200, 300, 400 y 500 que se asignará a las direcciones de memoria de prr+cont, y
lo que nos muestra el programa son las direcciones de memoria y el contenido
de esta que son los valores antes mencionados, que es precisamente lo que se
imprime.

c) Modificar las líneas 5 y 6 de tal modo que se utilice

CALLOC

Solo fue cambiadas las líneas 5 y 6 a las siguientes:

int *ptr = calloc(5,sizeof(int));

char *ptr2 = calloc(100,sizeof(char));

De lo anterior recuerde que reservamos 5 y 100 espacios respectiva-

mente para las ptr y ptr2, recuerde que CALLOC limpia los espacios así
que la impresión nos mostraría en nulos (cero) el contenido de los espa-
cios reservados que anteriormente en MALLOC los teníamos con ba-
sura.

d) Reemplaza la línea 17 con una instrucción

equivalente que genere el mismo resultado.

6
Ejercicio 2

Codifica, compila y ejecuta el código “ejercicio2” posteriormente responde las preguntas.

Análisis

a) Explica resultados

El resultado que se muestra en la pantalla es el resultado donde en la función principal no mandamos a lla-
mar a la función de imprimir alumno, por tanto, no aparecerá, lo único que es visible son las líneas:

printf("&din1[%d]=%d \n",j,din1+j);

printf("&din2[%d]=%d \n”,j,din2+j);

Que en lo que respecta a din1 y din2 nos muestran el contador dentro de los corchetes para mostrar el nú-
mero del arreglo y din1 + j y din2 + j nos indica que a la cantidad de memoria reservada para ellos los
asigna a din1 y din2, con las funciones CALLOC y MALLOC fue asignado pero recuerde que MALLOC
trae consigo basura que ha quedado en la memoria, mientras que CALLOC nos asigna muchos espacios de
memoria en el que primero va de la cantidad de elementos que deseamos insertar y luego la cantidad de es-
pacio que le deseamos asignar.

//el tipo sizeof(Alumno) es te tipo unsigned long, ya que es una di-

rección de memoria, por ello es: %lu. Además de eliminó el & de
las impresiones de din 1 y din 2.

b) Realloc para cambiar a 20

Se insertaron las líneas siguientes para cambiar el tamaño del vec-

tor:

Luego de esto solo modificamos el apuntador j para que su tope sea

20, de esta manera pudiera imprimir las direcciones de memoria
correspondientes. Nótese que es idéntico al ejercicio anterior solo que hemos redimensionado las variables

7
dinámicas para que ahora tenga un tamaño de 20.

c) Reemplazo de (Alumno*)malloc(5*sizeof(Alumno))

d) Forma de liberar la memoria reservada sin free.

Ejercicio 3
• Diseña un tipo de dato abstracto llamado libro en el cual puedas encapsular elementos como título,
autor, editorial, id del libro.
• Crear un arreglo dinámico de libros en el cual se solicite al usuario en tiempo de ejecución, el ta-
maño de dicho arreglo.
• Dentro de la función principal, el usuario deberá llenar el número de libros, determinando el tamaño
del arreglo. Recuerda que es recomendable el uso de funciones para trabajar con implementaciones.

Análisis

8
Conclusión

La práctica se enfoca directamente a la implementación de las variables dinámicas en lugar de usar

arreglos comunes para almacenar nuestras variables, ya que representa algunas desventajas:

• No se puede cambiar el tamaño del arreglo una vez asignado

• Hasta que termina la ejecución es liberada la cantidad de memoria que demanda el arreglo

El objetivo de la práctica:
• Utilizarás funciones en lenguaje C que permiten reservar y almacenar información de ma-
nera dinámica (en tiempo de ejecución).

Crítica constructiva:

Bibliografía

https://w3.ual.es/~acorral/DSO/Tema_3.pdfhttps://www.fing.edu.uy/tecnoinf/mvd/cur-
sos/prinprog/material/teo/prinprog-teorico08.pdf

https://www.tutorialspoint.com/c_standard_library/c_function_calloc.htm

El lenguaje de programación C. Brian W. Kernighan, Dennis M. Ritchie, segunda edición,

USA, Pearson Educación 1991.

https://msdn.microsoft.com/en-us/library/3f8w183e.aspx