Asignación de Memoria (Allocation) Algoritmos y Estructuras de Datos I. Asignación de Dinámica de Memoria

Transcripción

1 Asignación de Memoria (Allocation) Algoritmos y Estructuras de Datos I Segundo cuatrimestre de 2014 Departamento de Computación - FCEyN - UBA Programación imperativa - clase 14 Memoria dinámica y listas enlazadas Estática (o en tiempo de compilación) El compilador asigna la memoria necesaria para almacenar los valores asociados a cada variable del programa. El espacio de memoria requerido para almacenar los valores del tipo se conoce en tiempo de compilación. Dinámica (o en tiempo de ejecución) La memoria se asigna durante la ejecución del programa. El espacio de memoria asignado a un proceso varia durante la ejecución. Los valores se alojan en una parte de la RAM reservada al proceso denominada memoria dinámica (o heap). 1 2 Asignación de Dinámica de Memoria Para asignar dinámicamente espacio de memoria utilizamos el operador new, seguido por el tipo de valores a almacenar new int //asigna dinamicamente memoria para almacenar un int new float // asigna dinamicamente memoria para almacenar un double el operador new retorna la dirección de memoria donde comienza el espacio asignado. El tipo puntero a (*). Por ejemplo: int* p; //declara a la variable p como un puntero a un entero Los valores de p son direcciones de memoria que almacenan enteros. int* p; //declara a la variable p como un puntero a un entero p = new int //asigna memoria para almacenar un int //y guarda su direccion en p. Accesos a la memoria dinámica (desrefenciación) Para acceder al valor contenido en la memoria apuntada por un puntero, debemos desreferenciar: acceder a la posición de memoria apuntada por el puntero El operador de desreferenciación es * int* p = new int; //declara y asigna dinamicamente memoria para el puntero p *p = 5; //asigna a la memoria apuntada por p el valor 5 cout << *p; //muestra el valor 5 Notar diferencia con cout<<p que muestra una dirección de memoria. Las asignaciones son incorrectas int a; int* p;. p = 10; //MAL: p es de tipo puntero a entero, no un entero p = a; //MAL: p es de tipo puntero a entero, no un entero a = p //MAL: a es de tipo entero, no un puntero a entero 3 4

2 Asignación de punteros (Aliasing) Consideremos este código: *a = 10; int* b; b = a; // a y b apuntan a la misma direccion de memoria cout<<*b; // Muestra 10 *b = 5; cout<<*a //Muestra 5; Esto se debe a que las dos variables apuntan a la misma posición de memoria. El mismo fenómeno que ocurre cuando utilizamos referencias. Puntero a NULL Es un valor especial que indica que el puntero no está apuntando a ninguna posición de memoria. Se indica por la constante 0 (o una expresión que evalué 0). Puede usarse la macro NULL que está definida como el valor 0. a = 0; // a no apunta a ninguna posicion de memoria Si se desreferencia el puntero nulo se produce un error en tiempo de ejecución (Segmentation fault). a = NULL; // a no apunta a ninguna posicion de memoria cout<<*a; //Error: Se desreferencia al puntero a NULL 5 6 Alcance de las variables Alcance: Es la porción de código en dónde vale la asociación entre el nombre de la variable y la posición de memoria que designa la variable (es decir, donde es correcto usar el nombre de la variable para referirse a la posición de memoria). El alcance de las variables locales en C++ está designado por un par de llaves. int f() int n = 5; return n; Alcance de n Tiempo de vida de un objeto Tiempo de vida de un objeto es el lapso de ejecución del programa en el que una porción de memoria está reservada para almacenar a dicho objeto. Para las variables locales, el tiempo de vida coincide con la ejecución de su alcance. Para los objetos creados dinámicamente, el tiempo de vida no está determinado estáticamente. Alcance de n int* f () int* n = new int; return n; La memoria reservada con la operación new int no se libera al finalizar la ejecución del alcance en la que fue asignada. 7 8

3 Pérdida de memoria (Memory Leaks) Uso incorrecto de memoria Se asignó dinámicamente memoria que no puede accederse más, porque se pierden las referencias. a = 0; // se pierde la direccion de memoria asignada // La memoria asignada con new permanece inutilizable y debe ser liberada Para ello usamos el operador delete. delete a; // la memoria apuntada por a es liberada Para no perder memoria, cada porción de memoria que se asigna con new, debe liberarse con delete. 9 Referencias colgantes (Dangling references) Luego de ejecutar delete a la memoria apuntada por a no debería ser utilizada, sin embargo C++ no lo prohibe y es responsabilidad del programador. El código no produce error, pero accede mal a la memoria. *a = 5; delete a; cout<<*a; //Mal uso de memoria: acceso a memoria que ha sido liberada Algunos programadores utilizan la convención. Asignar el puntero a NULL luego de liberar *a = 5; delete a; a = 0; cout<<*a; //Error en tiempo de ejecucion Se resuelve el problema? No, en presencia de aliasing. 10 Referencias colgantes (Dangling references) Se resuelve el problema? No, en presencia de aliasing pueden quedar referencias colgantes int* a, *b; b = a; delete a; a = 0; cout<<*b; //Acceso incorrecto a memoria liberada Es responsabilidad del programador administrar el uso de la memoria. Dado que esto se considera una actividad de bajo nivel de abstracción, muchos lenguajes modernos liberan al programador de esta actividad Incorporando un recolector de basura (garbage collector). 11 Referencias a instancias de clases Considerar class Complex public: Complex(float r, float i); Complex suma(complex1 c); Complex resta(complex1 c); void show(); private: float real, imag; ; int main() Complex a = Complex(1,2); Complex* b = new Complex(10,4); a.show() (*b).show(); b -> show(); El operador -> es equivalente a dereferenciar y seleccionar una operación o un atributo. this es un puntero. 12

4 Arreglos Podemos pedir un arreglo de forma dinámica? Sí. Usando new[exp]. Pero la longitud queda fija para siempre. Tenemos que ocuparnos de liberar la memoria usando delete[] int n = 5; int[] a = new a[n]; delete a[]; Queremos una estructura para guardar datos, de largo variable. tipo Lista<T> observador elems(l:lista<t>): [T]; problema agregaradelante(l:lista<t>, e: T) modifica l; asegura elems(l)==e:elems(pre(l)); problema agregaratras(l:lista<t>, e: T) modifica l; asegura elems(l)==elems(pre(l))++[e]; problema quitarprimero(l:lista<t>) requiere elems(l) > 0; modifica l; asegura elems(l)==elems(pre(l))[1.. elems(pre(l) )]; Queremos una estructura para guardar datos, de largo variable. Idea: Pedir memoria para un por vez y guardar una referencia a este. Dónde? En un anterior! Creamos una estructura de datos Nodo que guarda el que queremos almacenar y un puntero a otro Nodo: Por ejemplo, creamos tres nodos de la forma (asumiendo es int): Nodo* nodo1 = new Nodo; nodo1 -> = 1; Nodo* nodo2 = new Nodo; nodo2 -> = 2; Nodo* nodo3 = new Nodo; nodo3 -> = 3; struct Nodo T ; Nodo* ; Graficamente: nodo1 nodo2 nodo3 La clausula struct permite definir estructuras agrupando diferentes componentes básicos. Es similar a class pero, al contrario que class, brinda por defecto accesibilidad pública a sus s. A veces se usa para definir estructuras de datos dentro de clases rerpesentando TADs

5 Luego, hacemos que el nodo1 referencie al nodo2 y el nodo2 al nodo3. El nodo3 referencia a null para indicar que es el final de la lista: nodo1 -> = nodo2; nodo2 -> = nodo3; nodo3 -> = NULL; Gráficamente: nodo1 nodo2 nodo3 Notemos entonces que con sólo mantener una referencia al primer nodo de la lista, podemos acceder a todos los s: prim Aprovechando esto, queremos construir una Lista que responda a las s operaciones: Lista<int> l; l.imprimir(); //imprime [] l.agregaradelante(2); l.imprimir(); //imprime [2] l.agregaradelante(4); l.imprimir(); //imprime [4 2] l.agregaradelante(2); l.imprimir(); //imprime [2 4 2] l.agregaradelante(8); l.imprimir(); //imprime [ ] Sólo mantenemos una referencia al primer nodo, con lo cual una Lista va a estar representada sólo por esta variable: template <class T> class Lista struct Nodo T ; Nodo* ; ; Nodo* primero; ; La lista vacía es aquella que no tiene un primer nodo, o dicho de otra manera, que el nodo primero vale NULL. Todo nodo referencia al nodo en la lista. Si es el último no referencia a ninguno, es decir, su variable vale NULL

6 Constructores y Destructores Constructor: Permite definir el valor inicial de una lista recien creada (estática o dinámicamente). Garantiza que se cumpla el invariante de representación! class Lista<T> Lista() primero = NULL; private: Nodo* primero; Destructor: Garantiza que cuando una instancia es destruida, se limpie también la memoria correspondiente a las instancias creadas o que dependen de ella. class Lista<T> ~Lista() // Luego volvemos a esto Método imprimir Para imprimir una lista, nos paramos en el primer y vamos recorriendo la lista utilizando la referencia al : class Lista<T> public: void imprimir() cout<<"["; Nodo* n = this -> primero; while (n!= NULL) cout<<n -> <<" "; n = n -> ; cout<<"]"<<endl; Método agregaradelante Cómo agregamos un al principio de la lista? Necesitamos crear un nuevo Nodo y que éste pase a formar parte de la lista. Para agregarlo adelante, debe pasar a ser el primer nodo de la lista, y debemos tener cuidado de que su variable apunte al nodo apropiado. void agregaradelante(t x) Nodo* nuevo = new Nodo; nuevo -> = x; nuevo -> = this -> primero; this -> primero = nuevo; Esquemas de iteración: arreglo Un esquema de iteración es la estructura algorítmica para recorrer los s de una estructura de datos. En un arreglo, recorremos los s con un ciclo con un índice: int i=0; while( i < n ) // hacer algo con arr[i] ++i; 23 24

7 Esquemas de iteración: lista En la lista, tenemos que crear una referencia a nodo, que se inicializa con el primer nodo de la lista y en cada paso se actualiza con el nodo: Nodo* n = this -> primero; while (n!= NULL) // hacer algo con n. n = n -> Este algoritmo puede alterarse para frenar en el último o en un buscado. Método largo Ejercicio: escribir un método int largo() que devuelve el largo de la lista. int largo() int l=0; Nodo* n = this->primero; while (n!= NULL) l++; n = n -> ; return l; Método agregaratras Siguiendo con la lista del primer ejemplo, incluyamos el método: l.imprimir(); //imprime [ ] l.agregaratras(16); l.imprimir(); //imprime [ ] l.agregaratras(32); l.imprimir(); //imprime [ ] Método agregaratras Ejercicio: codificar la función agregaratras Solución: void agregaratras(t x) Nodo* nuevo = new Nodo; nuevo -> = x; if(this -> primero==null) // Esta vacia? this -> primero = nuevo; else // Avanzar hasta el ultimo Nodo* n = this -> primero; while(n ->!=NULL) n = n -> ; n -> = nuevo; 27 28

8 Método quitarprimero Eliminar el primer de la lista l.imprimir(); //imprime [ ] l.quitarprimero(); l.imprimir(); //imprime [ ] Tenemos que asegurarnos de liberar le memoria del eliminado void quitarprimero() Nodo * n = this -> primero; // El nuevo primero es el this -> primero = this -> primero -> ; // Libero la memoria delete n; Destructor El destructor se ocupa de limpiar lo hecho por la instrancia destruida. En particular debe liberar la memoria ocupada por las instancias que pudo haber creado. en el caso de la Lista enlazada se debe ocupar la memoria ocupada por cada nodo. class Lista<T> ~Lista() Nodo* n = this -> primero; while(n!=null) Nodo* sig = n -> ; delete n; n=sig; Ampliando la clase (1) Qué orden de complejidad tiene la función largo()? Ampliamos la clase agregando una variable de instancia con la cantidad de nodos de la lista: template <class T> class Lista<T> Nodo* primero; int nodos; - Ampliando la clase (1) Cambia el constructor Lista() primero = NULL; nodos = 0; Cuál sería el invariante de representación? y el abs? Tenemos que actualizar el código de los métodos que actualizan la lista! 31 32

9 - Ampliando la clase (1) Cambia el método agregaradelante void agregaradelante(int x) Nodo* nuevo = new Nodo; nuevo -> = x; nuevo -> = this -> primero; this -> primero = nuevo; ++nodos; y todos los métodos que alteren los nodos de la lista! - Ampliando la clase (1) Cuál es la ventaja de haber agregado esta variable? Ahora el método largo es más eficiente! int largo() return nodos; En la versión anterior, este método tenía complejidad O(n), y la versión actual tieme complejidad O(1). Mejoramos la eficiencia de uno de los métodos, sin empeorar el orden del resto (sólo agregamos una instrucción a cada uno) Ampliando la clase (2) Cómo es el algoritmo para agregar un al final de la lista? (lo llamamos agregaratras). La representación de listas con una referencia al primer genera una asimetría entre los métodos agregaradelante y agregaratras. Agregar al principio es O(1). Agregar al final es O(n), porque tenemos que recorrer toda la lista para localizar el último nodo. - Ampliando la clase (2) Una instancia de ListaInt tiene ahora dos referencias: Solución: Mantener una referencia al último nodo! class Lista<T> Nodo* primero; Nodo* ultimo; Ahora, el método agregaratras no necesita recorrer la lista para ubicar el último nodo, y entonces pasa a ser O(1). Tenemos que actualizar los métodos que modifican la lista

10 Listas doblemente enlazadas Cada nodo tiene una referencia al, y también una referencia al anterior. 37