ASIGNACIÓN DINAMICA DE MEMORIA

Para crear y mantener estructuras dinámicas de datos se requiere la asignación dinámica de memoria, la cual
permite que un programa obtenga más memoria en tiempo de ejecución, para almacenar nuevos nodos.
Cuando el programa ya no necesita la memoria, esta se puede liberar para que se pueda reutilizar al asignar
otros objetos en el futuro. El límite para la asignación dinámica de memoria puede ser tan grande como la
cantidad de memoria física disponible en la computadora, o la cantidad de memoria virtual disponible en un
sistema con memoria virtual.

Tambien se puede decir que la asignación de memoria dinámica significa que la reserva de memoria se realiza
dinámicamente en tiempo de ejecución, no siendo necesario entonces tener que especificar en la declaración
de variables la cantidad de memoria que se va a requerir. La reserva de memoria dinámica añade una gran
flexibilidad a los programas porque permite al programador la posibilidad de reservar la cantidad de memoria
exacta en el preciso instante en el que se necesite, sin tener que realizar una reserva por exceso en prevención
a la que pueda llegar a necesitar.

A menudo, los limites son mucho mas pequeños ya que la memoria disponible en la computadora debe
compartirse entre muchos programas.

La asignación dinámica de memoria de un objeto existe hasta que es liberada explícitamente por el
programador, o por la salida de un bloque o por el recolector de basura. En este contexto, se dice que ese
objeto tiene tiempo de vida dinámico.

El operador new recibe como argumento el tipo de objeto que se va a asignar en la forma dinámica y
devuelve un apuntador a un objeto de este tipo. También la memoria reservada de forma dinámica suele estar
alojada en el heap o almacenamiento libre, y la memoria estática en el stack o pila (con excepción de los
objetos de duración estática, los cuales suelen colocarse en una zona estática de datos). La pila suele ser una
zona muy limitada. El heap, en cambio, en principio podría estar limitado por la cantidad de memoria
dinámica.

Generalmente la memoria es asignada desde una gran pool o memoria sin usar, llamada heap. La ubicación
exacta de la memoria asignada no es conocida, por lo tanto esa memoria es accedida indirectamente,
generalmente vía referencia.

VENTAJAS DE USO EN C++

En C las funciones malloc() y free() asignan y liberan memoria de un bloque de memoria denominado el
montículo del sistema. La función malloc() asigna memoria utilizando asignación dinámica debido a que
puede gestionar la memoria utilizando la ejecución de un programa.

Sabiendo esto sobre las funciones en C pasemos a C++ que ofrece un nuevo y mejor método para gestionar la
asignación dinámica de memoria, los operadores new y delete, que asignan y liberan la memoria de una zona
de memoria llamada almacén libre.

Los operadores new y delete son más versátiles que maloc() y free(), ya que ellos pueden asociar la
asignación de memoria con el medio que lo utiliza. Son más fiables, ya que el compilador realiza verificación
de tipos cada vez que un programa asigna memoria con new.

Otra ventaja proviene del hecho de que new y delete se implementan como operadores y no como funciones.
Esto significa que new y delete se construyen en el propio lenguaje de modo que los programas pueden
utilizar new y delete sin incluir ningún archivo de cabecera.
Existe otra característica importantes de los operadores new y delete y es que ellos nunca requieren moldeado
(conversión forzosa de tipos) de tipos y eso hace que new y delete más fáciles de utilizar que malloc() y
free().
Los objetos creados con new residen en el almacenamiento libre. Los objetos del almacenamiento libre se
eliminan con el operador delete.

OPERADORES NEW Y DELETE

Operador new:
C++ proporciona otro método para obtener bloques de memoria: el operador new. El operador new asigna un
bloque de memoria que es el tamaño del tipo de dato. El dato u objeto dato puede ser un int, un floar, una
estructura, un array o cualquier otro tipo de dato. El operador new devuelve un puntero, que es la dirección
del bloque asiganado de memoria. El puntero se utiliza para referenciar el bloque de memoria.
El operador opcional :: está relacionado con la sobrecarga de operadores. Lo mismo se aplica a
emplazamiento.
La inicialización, si aparece, se usará para asignar valores iniciales a la memoria reservada con new, pero no
puede ser usada con arrays.
Las formas tercera y cuarta se usan para reservar memoria para arrays dinámicos. La memoria reservada con
new será válida hasta que se libere con delete o hasta el fin del programa, aunque es aconsejable liberar
siempre la memoria reservada con new usando delete. Se considera una práctica muy sospechosa no hacerlo.
Si la reserva de memoria no tuvo éxito, new devuelve un puntero nulo, NULL. El operador delete se usa para
liberar la memoria dinámica reservada con new.

Operador delete:
Cuando se ha terminado de utilizar un bloque de memoria previamente asignado por new, se puede liberar el
espacio de memoria y dejarlo disponible para otros usos, mediante el operador delete.
El bloque de memoria suprimido se devuelve al espacio de almacenamiento libre, de modo que habrá más
memoria disponible para asignar otros bloques de memoria. La expresión será normalmente un puntero, el
operador delete[] se usa para liberar memoria de arrays dinámicos.
Es importante liberar siempre usando delete la memoria reservada con new. Existe el peligro de pérdida de
memoria si se ignora esta regla. Cuando se usa el operador delete con un puntero nulo, no se realiza ninguna
acción. Esto permite usar el operador delete con punteros sin necesidad de preguntar si es nulo antes.
De todos modos, es buena idea asignar el valor 0 a los punteros que no han sido inicializados y a los que han
sido liberados. También es bueno preguntar si un puntero es nulo antes de intentar liberar la memoria
dinámica que le fue asignada.

EJEMPLOS

Operador new:

# include <iostream.h>
#include <string.h> // uso de strcpy()
Void main()
{
Char*cad = “Sierras de Cazorla, Segura y Magina”;
Int lon = strlen(cad);

Char *ptr;
ptr = new char[lon+1];

strcpy (ptr, cad); // copia cad a nueva area de memoria

// apuntada por ptr

Cout << endl << “ptr = “ << ptr; // cad esta ahora en ptr
Operador delete:

//Muestra la asignación dinámica de una cadena de caracteres

#include <iostream.h>
#include <string.h>

Void main (void)

Char *p;

p = new char[80];

strcpy(p, “Tu tio esta el loma linda”)

cout <<p<<endl;

delete p;

cout <<” Pulse intro para continuar”;

cin.get();
int main() {
} char *c;
int *i = NULL;
float **f;
int n;

// Cadena de 122 más el nulo:

c = new char[123];

// Array de 10 punteros a float:

f = new float *[10]; (1)

// Cada elemento del array es un array de 10 float

for(n = 0; n < 10; n++) f[n] = new float[10]; (2)

// f es un array de 10*10

f[0][0] = 10.32;
f[9][9] = 21.39;
c[0] = 'a';
c[1] = 0;

// liberar memoria dinámica

for(n = 0; n < 10; n++) delete[] f[n];