Sesión 07: Manejo Dinámico de Memoria

Presentación del tema: "Sesión 07: Manejo Dinámico de Memoria"— Transcripción de la presentación:

1 Sesión 07: Manejo Dinámico de Memoria

2 Contenido 1 Apuntadores Zonas de Memoria 2 Manejo Dinámico de Memoria
3 Manejo Dinámico de Memoria 4 Referencias

3 Direcciones de Memoria
La declaración de una variable involucra necesariamente 4 cosas: 1000 1001 1002 y 1003 1004 z 1005 1000 1001 1002 y 1003 1004 1005 1000 1001 1002 1003 1004 1005 int y; 25 int y=25; int z=77; 77 El nombre, El tipo de Datos, Su valor y … Su Dirección en memoria.

4 Apuntadores Las variables vistas hasta este momento contienen valores cualquiera de datos cualquiera, por el contrario los apuntadores contienen valores que son direcciones de memoria donde se almacenan otras variables. Utilizando variables punteros un programa puede realizar muchas tareas que no sería posible solo utilizando tipos de datos estándar.

5 Apuntadores Cuando se declara una variable en C, el compilador establece un área de memoria para almacenar el contenido de la variable. Esa variable se sitúa en una posición específica de la memoria, conocida como dirección de memoria. 1000 1001 1002 y 1003 1004 z 1005 1000 1001 1002 1003 1004 1005 1000 1001 1002 y 1003 1004 1005 25 77 25 Se utilizan los apuntadores para optimizar el acceso a esas variables. int y=25; Un puntero en C es una Variable que SOLO guarda la dirección de memoria de otra variable. int z=77;

6 Apuntadores Es un tipo de variable implementada para almacenar exclusivamente direcciones de otras variables, estos se debe declarar y definir de acuerdo al tipo de dato que apunta.

7 Apuntadores Algunas características de los apuntadores:
Los apuntadores siempre deben inicializarse Aquellos apuntadores que son inicializados con una valor igual a cero (0), se denominan apuntadores NULL. Aquellos punteros que no sean inicializados a ningún valor se denominan “wild pointer”, y son extremadamente peligrosos pues pueden estar apuntando a cualquier cosa.

8 Violación de seguridad de la memoria
“Dangling pointer” Un objeto apuntado se suprime sin modificar el puntero Si se reasigna ese espacio libre en memoria, el puntero referenciará la nueva variable. “Wild pointer” Se crea un puntero y se usa antes de la inicialización El puntero puede estar apuntado a cualquier posición desconocida de memoria Generan corrupción de datos y posiblemente fallos de segmentación.

9 ¿Para que se usan los Apuntadores?
El uso de los apuntadores es utilizado para múltiples funciones, tales como: Acceder de manera indirecta a una variable, se accede por medio de su dirección. El utilizar punteros como “valor de retorno” permite superar la limitación de las funciones de devolver un único valor. Acceder a los atributos y métodos de un objeto. Gestionar datos en memoria. Manipular datos en el Free store (Heap).

10 Declaración de Apuntadores
Como cualquier variable, las variables punteros han de ser declaradas antes de utilizarlas. Se utiliza asterisco (*) para indicar que la variable es variable apuntador. tipoDatoApuntado *nombreVbleApuntador; Ejemplos: int *ptr1; // Puntero a un tipo de dato entero (int) char *ptr2; // Puntero a un tipo de dato char float *f; // Puntero a un tipo de dato float SIEMPRE que aparezca un asterisco ( * ) en una declaración de una variable, ésta es una variable apuntador.

11 Declaración de Apuntadores
Nota: Se utiliza la palabra reservada void en la declaración de apuntadores, cuando se quiere que el puntero pueda apuntar a cualquier tipo de variables, int , char, float,….

12 Inicialización de Apuntadores
int i; /* Define una variable i */ int *ptr = &i; /* Define un puntero a un entero ptr y almacena dirección de i */ MAPA DE MEMORIA ????? 5020 5021 5022 i 5023 5024 ptr …….. 5022

13 Operadores Operadores Vistos & * Obtiene la dirección de una variable. Define una variable como puntero (DECLARACIÓN). Accede el contenido de una variable puntero (PROCEDIMIENTO). C++ requiere que las variables puntero direccionen realmente variables del mismo tipo de dato que está ligado a los punteros en sus declaraciones.

14 Indirección Se puede acceder al valor de una variable apuntada utilizando el nombre del apuntador. En el procedimiento del algoritmo simplemente se le antepone "*" al nombre del apuntador y se accede al valor de la variable de una forma común y corriente 5020 5021 5022 i 5024 var1 ptr …. //Ejemplo void main(void) { int var1; int i=3; int *ptr; ptr = &i; var1=*ptr; var1++; *ptr=var1; }

15 Utilizando Apuntadores
Apuntadores a Funciones Prototipo: int funcionApunt(int *ptr1, int *ptr2); Definición: int funcionApunt(int *ptr1, int *ptr2){ *ptr1=*ptr2; cot<< *ptr1; return *ptr1 + *ptr2; } Llamado a la función: void main(void){ int *ptr1, *ptr2,a,var1,var2; ….. a=funcionApunt(&var1,&var2); a=funcionApunt(ptr1,ptr2);

16 Apuntadores y POO En la programación Orientada a Objetos, los apuntadores trabajan con los objetos como variables normales, es decir, el puntero se carga con la dirección del objeto correspondiente. Ahora para acceder a los miembros del objeto tendríamos lo siguiente; (* apuntadorObjeto).miembro apuntadorObjeto -> miembro

17 El Puntero “this” Todas las clases tienen un puntero escondido denominado “this”, el cual apunta sobre la dirección del objeto en cuestión. No hay necesidad de preocuparse de la creación ni el borrado de este puntero, pues el compilador se encarga de esto.

18 Puntero this class myCicla{ private: int color; public: myCicla();
void setColor(int _color); int getColor(); ~myCicla(); }; void myCicla::setColor(int _color){ color=_color; } this->color=_color;

19 Puntero this Qué pasa si un método de una clase necesita como argumento un objeto de la misma clase? R/ ejemplo Complejos

20 Resumen de apuntadores
Expresión Lectura *x Apuntado por x &x Dirección de x x.y Miembro y del objeto x x->y Miembro y del objeto apuntado por x (*x).y x[0] Primer objeto apuntado por x x[1] Segundo objeto apuntado por x x[n+1] Objeto (n+1) apuntado por x

21 Pasando punteros const
Cuando se pasa un puntero de un objeto como parámetro de una función, ocurre el riesgo de modificar la variable y sus métodos. Para evitar este inconveniente se pueden usar punteros a objetos constantes, con el cual sólo se podrá usar los métodos constantes, protegiendo sus miembros.

22 Uso de punteros constantes
const int * pUno; // El valor al que apunta pUno //no puede ser modificado int * const pDos; // El valor de dirección no // puede ser modificada const int * const pTres; // ni el valor de la dirección, ni el valor al que apunta pTres puede ser modificado

23 Ejemplo punteros constantes
myCicla3::myCicla3(){ color=0; } myCicla3::~myCicla3(){} int myCicla3::getColor() const{ return color; void myCicla3::setColor(int _color){ color=_color; Ejemplo punteros constantes class myCicla3{ private: int color; public: myCicla3(); void setColor(int _color); int getColor() const; ~myCicla3(); }; const myCicla3 mybike; const myCicla3 *ptr_mybike=&mybike; int color; int main(){ ptr_mybike->setColor(4); //error compilador color=ptr_mybike->getColor(); cout<<"el color es:"<<color<<endl; }

24 Contenido 1 Apuntadores Zonas de Memoria 2 Manejo Dinámico de Memoria
3 Manejo Dinámico de Memoria 4 Referencias

25 Modo de almacenamiento
El modo de almacenamiento (storage class) es otra característica de las variables de C++ que determina cuándo se crea una variable, cuándo deja de existir y desde dónde se puede acceder a ella. auto Es creada al comenzar a ejecutarse un bloque de código y deja de existir cuando el bloque se termina de ejecutar. (Por defecto) extern Estas variables existen durante toda la ejecución del programa. Una variable extern es definida o creada el momento en el que se le reserva memoria. permiten transmitir valores entre distintas funciones y ficheros static static se declaran dentro de un bloque como las auto, pero permanecen en memoria durante toda la ejecución del programa como las extern. La inicialización sólo se realiza la primera vez. register Este modo es una recomendación para el compilador, con objeto de que si es posible ciertas variables sean almacenadas en los registros de la CPU y los cálculos con ellas sean más rápidos.

26 Espacios de memoria Segmento de código Memoria estática
Es una zona de memoria donde se reservan y se liberan “trozos” durante la ejecución de los programas según sus propias necesidades, este proceso es usualmente llamado gestión de memoria dinámica. Optimiza el almacenamiento de datos. Es una zona de memoria que gestiona las llamadas a funciones durante la ejecución de un programa. Cada vez que se realiza una llamada a una función en el programa, se crea un entorno de programa que se libera cuando acaba su ejecución. La reserva y liberación de la memoria la realiza el S.O. de forma automática durante la ejecución del programa. Reservada antes de la ejecución del programa Permanece fija. No requiere gestión durante la ejecución. El sistema operativo se encarga de la reserva, recuperación y reutilización. Se accede a un espacio en esta cada vez que se declaran Variables globales o tipo static. Segmento de código Memoria estática Free store (Heap) Espacio Libre Stack (Pila)

27 Stack Es un área muy importante manejada automaticamente para alojar datos durante la ejecución del programa.  Es un almacén de datos contiguos del tipo LIFO ("Last In First Out"). 

28 Stack Se usa para muchas cosas:
Se almacenan las variables locales automáticas y los datos involucrados en el mecanismo de invocación de funciones. En algunos sistemas, la pila y el heap son contiguos y el crecimiento desmesurado de la pila puede llegar a sobrescribir el área inferior del heap.

29 Free store (Heap) El Free Store es un espacio de memoria muy grande, donde es posible almacenar información, pero sólo puede ser manipulado por medio de punteros. A diferencia que en el Stack, la memoria reservada en el Free Store no se libera sino hasta que se termina el programa o es liberada manualmente.

30 Free store (Heap) Para reservar memoria en el Heap es necesario usar el comando new, el cual devuelve la dirección donde se reservó la variable. Rectangulo *pPuntero = NULL; pPuntero = new Rectangulo(); /*también es posible hacerlo todo en una sola línea. Rectangulo *pPuntero = new Rectangulo(); */

31 Contenido 1 Apuntadores Zonas de Memoria 2 Manejo Dinámico de Memoria
3 Manejo Dinámico de Memoria 4 Referencias

32 Gestión Dinámica de Memoria
Petición al S.O. (tamaño) El S.O. comprueba si hay suficiente espacio libre. Si hay espacio suficiente, devuelve la ubicación donde se encuentra la memoria reservada, y marca dicha zona como memoria ocupada.

33 Gestión Dinámica de Memoria
4. La ubicación de la zona de memoria se almacena en una variable estática (p1) o en una variable automática (p2). Nota: Si la petición devuelve una dirección de memoria, p1 y p2 deben ser variables de tipo puntero al tipo de dato que se ha reservado.

34 Gestión Dinámica de Memoria
5. A su vez, es posible que las nuevas variables dinámicas creadas puedan almacenar la dirección de nuevas peticiones de reserva de memoria.

35 Gestión Dinámica de Memoria
6. Una vez que se han utilizado las variables dinámicas y ya no se van a necesitar más es necesario liberar la memoria que se está utilizando e informar al S.O. que esta zona de memoria vuelve a estar libre para su utilización.

36 Gestión Dinámica de Memoria
1 Reservar memoria. 2 Utilizar memoria reservada. 3 Liberar memoria reservada.

37 Operador new Un operador que reserva la cantidad de memoria deseada en tiempo de ejecución. new reserva una zona de memoria en el Heap del tamaño adecuado para almacenar un dato de cualquier tipo, devolviendo la dirección de memoria donde empieza la zona reservada. Si new no puede reservar espacio (Ej. no hay suficiente memoria disponible), se provoca una excepción y el programa termina. La única forma de crear, modificar, acceder o eliminar una variable en el Heap es a través de un puntero. Se puede gestionar memoria para almacenar variables de tipo predefinido (int, float, double, …) al igual que los tipos de datos creados por el usuario (estructuras, clases…).

38 Operador new Este operador permite crear un objeto de cualquier tipo, incluyendo tipos definidos por el usuario, y devuelve un puntero (del tipo adecuado) al objeto creado. Su utilización exige que se declarare un puntero del tipo adecuado. Sintaxis: Tipo *puntero = new Tipo;

39 Operador new Tipo *ptr =new Tipo; Ejemplos: char *ptr =new char;
int *ptr =new int; float *ptr =new float; Rectangulo *ptr =new Rectangulo; Rectangulo *ptr =new Rectangulo(x,y);

40 Liberando la memoria del heap
Para liberar la memoria del HEAP se usa el comando delete sobre el puntero. delete pPuntero; Es MUY importante liberar la memoria del Heap, pues en caso de perder el rastro de los punteros podrán presentarse “fugas de memoria”

41 Operador delete El operador delete no elimina el puntero, simplemente lo desreferencia. int *ptr =new int;; //reserva memoria ... operaciones delete ptr; //desreferncia ptr ptr=NULL; //lo lleva a NULL delete ptr; //no hay problema //se puede volver a referenciar a otro espacio de memoria ptr=new char; ????

42 Operador new[ ] y delete[ ]
El estándar C++ posee los operadores new y delete para manipular manualmente la memoria, permitiéndonos tomar la decisión en el ciclo de vida de las variables. Además de ser utilizado para variables y objetos simples, también nos permite crear y destruir arreglos de manera dinámica. Sintaxis: Tipo *puntero = new Tipo [tamaño];

43 Operador new[ ] y delete[ ]
Ejemplos: Tipo *ptr =new Tipo; char *ptr =new char[5]; int *ptr =new int[10]; float *ptr =new float[size]; Rectangulo *ptr =new Rectangulo[3]; Rectangulo *ptr =new Rectangulo[3](x,y); //Error, solo acepta el constructor por defecto

44 Fugas de memoria Cuando “se pierde de vista” la dirección o el puntero que lleva registro del espacio en el Heap, se dice que hubo una fuga de memoria. La memoria desperdiciada por causa de fugas de memoria, NO podrá liberarse sino hasta que termine el programa.

45 Fugas de memoria Es muy frecuente que ocurra cuando el puntero es declarado como variable local (dentro de una función) y luego se sale de ésta sin antes liberar la memoria. Es muy común usar los constructores para reservar memoria en el heap y los destructores para liberarla.

46 Uso de objetos en el free store
La asignación de un objeto en el Heap es igual que la asignación de cualquier otro tipo Rectangulo *pRect= new Rectangulo; /*Este comando creará un objeto tipo Rectangulo en el Heap, llamando su contructor*/

47 Contenido 1 Apuntadores Zonas de Memoria 2 Manejo Dinámico de Memoria
3 Manejo Dinámico de Memoria 4 Referencias

48 Referencias Las referencias son “alias” de otros objetos, por lo tanto cuando se manipula una referencia, realmente se está manipulando el objeto al que ésta hace referencia.

49 Referencias Las referencias difieren con otro tipo de variables ya que deben declararse inicializándolas con las variables a las que harán referencia. Si se tratan de declarar sin inicializar, el programa no compilará. int Edad = 5; int &rVble = Edad; // errores!, esta mal referenciado int &rVble; &rVble = x;

50 Referencias Si se toma la dirección de una referencia (&rReferencia), el valor que devuelve es la dirección de la variable a la que apunta la referencia.

51 Rectangulo r1; Rectangulo &ref2=r1; Referencias r1, ref2 0X0FDE00

52 Referencias Las referencias sólo pueden ser asignadas UNA SOLA VEZ, por lo tanto, todas las operaciones que se hagan a la referencia, en realidad se estarán haciendo sobre el objeto al que hacen referencia. ¡NO TRATE DE REASIGNAR UNA REFERENCIA!

53 Referencias Las referencias pueden trabajar con todo tipo, incluso con objetos. Cuando una referencia hace referencia a un objeto, puede usar todos sus miembros y métodos tal y como se hace con objeto real.

54 Pasar y retornar valores por referencia
A las funciones normalmente se le pasan los argumentos por valor y sólo devuelven un valor. Si se pasan los parámetros por referencia, se puede superar éstas limitantes. Existe dos formas de hacerlo; usando punteros o referencias Se dice que uno pasa “por referencia” cuando usa punteros o uno pasa “una referencia” cuando usa referencias.

55 Pasar y retornar valores por referencia
Cuando se pasa referencias, realmente se pasa la dirección del objeto real (en vez del objeto entero), para luego manipular directamente el objeto, no su copia.

56 Retornos múltiples valores en las funciones
Existen 2 formas de hacerlo: & * Estos métodos permiten que se use el valor de retorno de la función para reportar errores.

57 Pasar por referencia para ser más eficiente
Cada vez que se pasa un objeto por valor, se genera una copia de éste en la pila, lo cual hace que se requiera tiempo y memoria. Cuando se trabajan con valores sencillos(int, short, etc..), es un costo tribial; sin embargo, con objetos complicados es un costo significativos.

58 Ejemplo funciones por referencia
using namespace std; void permutar1(int a, int b); void permutar2(int *ptr_a,int *ptr_b); void permutar3(int &a,int &b); int main(){ int num1=8; int num2=9; cout<<"Antes de utilizar la funcion1: "<<endl; cout<<"valor Variable1: "<<num1<<endl; cout<<"valor Variable2: "<<num2<<endl; //Paso de argumentos por referencia //mediante punteros // int *ptr_a=&num1 , int *ptr_b=&num2 void permutar2(int *ptr_a,int *ptr_b){ int temp=*ptr_a; *ptr_a=*ptr_b; *ptr_b=temp; } //Paso de argumentos mediante //referencias //int &a=num1 , int &b=num2 void permutar3(int &a,int &b){ int temp=a; a=b; b=temp; } //Paso de argumentos por valor //int a=num1 , int b=num2 void permutar1(int a, int b){ int temp=a; a=b; b=temp; } permutar3(num1,num2); cout<<"luego de utilizar la funcion3: "<<endl; cout<<"valor Variable1: "<<num1<<endl; cout<<"valor Variable2: "<<num2<<endl; permutar2(&num1,&num2); cout<<"luego de utilizar la funcion2: "<<endl; cout<<"valor Variable1: "<<num1<<endl; cout<<"valor Variable2: "<<num2<<endl; permutar1(num1,num2); cout<<"luego de utilizar la funcion1: "<<endl; cout<<"valor Variable1: "<<num1<<endl; cout<<"valor Variable2: "<<num2<<endl; return 0; }

59 Cuando usar referencias o punteros
Trabajan directamente con posiciones de memoria, pero el código mas limpio y fácil de usar Trabajan directamente con posiciones de memoria No pueden ser reasignados Se pueden reasignar, (reuso de punteros) Las referencias no pueden ser nulas. Pueden tomar el valor de nulo en el flujo del programa Poco costoso para manejo de funciones.

60 Bibliografía man, ¡no dude en utilizarlo!!
Como Programar en C++ - Deithel & Deithel Ed. PRENTICE HALL Sams Teach Yourself C++ in One Hour a Day, J. Liberty,S. Rao, B. Jones