Memoria Dinámica

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 3

Actividad 9.

Memoria dinámica
Dea Laura Donaji Angel Gonzalez
21310202 2F
Programacion Orientada a Objetos

Cuando el sistema operativo carga un programa para ejecutarlo y lo convierte en proceso, le


asigna cuatro partes lógicas en memoria principal: texto, datos (estáticos), pila y una zona
libre. Esta zona libre (o heap) es la que va a contener los datos dinámicos, la cual, a su vez,
en cada instante de la ejecución tendrá partes asignadas a los mismos y partes libres que
fragmentaran esta zona, siendo posible que se agote si no se liberan las partes utilizadas ya
inservibles. (La pila también varía su tamaño dinámicamente, pero la gestiona el sistema
operativo, no el programador):
Para trabajar con datos dinámicos necesitamos dos cosas:
1. Subprogramas predefinidos en el lenguaje que nos permitan gestionar la memoria
de forma dinámica (asignación y liberación).
2. Algún tipo de dato con el que podamos acceder a esos datos dinámicos (ya que
con
los tipos vistos hasta ahora sólo podemos acceder a datos con un tamaño y forma
ya determinados).
¿Qué es la memoria dinámica?
La memoria dinámica es un espacio de almacenamiento que se puede solicitar en tiempo de
ejecución. Además de solicitar espacios de almacenamiento, también podemos liberarlos
(en tiempo de ejecución) cuando dejemos de necesitarlos.
Para realizar esta administración de la memoria dinámica, C++ cuenta con dos
operadores new y delete. Antes de utilizarlos, debemos incluir el encabezado <new>.
El operador new reserva memoria dinámica de cualquier tipo, esto es:
 tipos primitivos (int, double, etc)
 tipos definidos por el usuario (clases o estructuras).
Con ayuda de los punteros C++ permite reservar dinámicamente espacios de memoria
ubicados en la zona que se conoce como Heap que comparte los recursos de memoria con
el Stack. Para la reserva de memoria existen dos operadores, el primero es el
operador new que se utiliza para reservar posiciones individuales de memoria del tamaño
del tipo de dato que se va a alojar en esa posición. Mientras que el operador new[] permite
reservar al tiempo varias posiciones consecutivas de memoria como en el caso de arreglos.

El problema con la reserva dinámica de memoria es que debe ser liberada de nuevo de
manera manual una vez no se necesita más, ya que en C++ a diferencia de otros lenguajes
de programación no existe una entidad que se encargue de hacer esta liberación de memoria
de manera automática (ejemplo: garbage collector), por tanto es necesario el uso de otros
operadores o funciones que permitan realizar esa liberación de memoria, que en caso de no
hacerse correctamente da lugar al problema de fuga de memoria o "memory leak".
Entonces para liberar la memoria previamente reservada existen los
operadores delete y delete[] que siven para liberar la memoria reservada con los
operadores new y new[] respectivamente. 
NOTA: Para evitar el problema de fuga de memoria las nuevas versiones de C++ vienen
con unas clases especiales llamadas Smart Pointers que automatizan el proceso de
liberación de memoria y además brindan métodos para la reserva de memoria sin necesidad
de utilizar directamente los operadores new y new[].

¿Para que se utiliza la memoria dinámica?


 Permite reservar/liberar memoria bajo demanda
 Libera al programador de saber dónde colocar sus estructuras en memoria
 Evita limites por culpa de variables estáticas
 Facilita implementar estructuras de datos dinámicas como listas, arboles, en el que no se
conoce a priori su tamaño final
 Mejor aprovechamiento de la memoria

Veamos las siguientes líneas:

int *ptrEntero;
ptrEntero = new int;
/*(al puntero ptrEntero le asignamos
dinamicamente espacio para contener un valor int)*/

int *ptrEnteroA;
ptrEnteroA = new int(5);
/*(igual que al anterior
pero de paso lo inicializamos en 5)*/

También podríamos hacerlo con un arreglo, para esto:

int *arreglo = new int[45];


/*
(creamos un arreglo dinámico, ésta vez lo
hacemos en la misma línea en la que
declaramos el puntero)
*/

Supongamos ahora que poseemos una clase Punto, podríamos crear objetos dinámicos a
partir de esta clase.

Punto *ptrQ;
ptrQ = new Punto(4,5);
/*
(en la segunda línea le pasamos
además dos parámetros separados por
coma al constructor de Punto)
*/

Hemos estado pidiendo memoria dinámica, una vez utilizada lo correcto sería liberarla antes
de que finalice el programa para esto utilizaremos el operador delete:
delete ptrEntero;
delete ptrEnteroA;
delete ptrQ;
delete [] arreglo;
//Si no usaramos [] no se liberaría el arreglo entero

Bibliografía.

Bibliografía

Coding games and programming challenges to code better. (s/f). CodinGame.

Recuperado el 18 de mayo de 2022, de

https://www.codingame.com/playgrounds/51214/manejo-dinamico-de-

memoria-y-polimorfismo-practica-4/asignacion-y-liberacion-dinamica-de-

memoria

Memoria dinamica. (s/f). Upc.edu. Recuperado el 18 de mayo de 2022, de

https://docencia.ac.upc.edu/FIB/grau/SO2/documents/tema6.pdf

Memoria Dinamica. (s/f). Uma.es. Recuperado el 18 de mayo de 2022, de

http://www.lcc.uma.es/~lopez/lp2/apuntes/03-punteros/memoria_dinami

ca.pdf

Memoria dinamica: new y delete en C++. (s/f). Blogspot.com. Recuperado el 18 de

mayo de 2022, de http://codigomaldito.blogspot.com/2006/01/memoria-

dinamica-new-y-delete.html

También podría gustarte