Clase 10 Apuntadores & Memoria Dinámica Programación III Clase 10 Apuntadores & Memoria Dinámica

Operadores para uso de Memoria Dinámica Significado new type Reserva en memoria espacio para un objeto de tipo type y retorna su dirección delete ptr Libera la memoria del objeto al que apunta ptr new type[expr] Crea un arreglo de type de tamaño de expr delete[] ptr Libera la memoria del arreglo al que apunta ptr

Ejemplo de Memoria Dinámica int* pInt = new int; *pInt = 17; cout << pInt<< endl; cout << *pInt<<endl; delete pInt; HS 0x4CD0 17 SS / DS 0x4CD0 0x3F3A pInt 17 0x4CD0

Ahora, para crear arreglos dinámicos HS int size = 3; float* fp = NULL; fp = new float[size]; for(int i=0;i<size;i++) fp[i] = 2 * i; ... delete[] fp; 0x4CD0 0x4CD4 0x4CD8 1 4 SS / DS 0x3F3A fp NULL 0x3F12 size 3 0x4CD0

Acerca del operador delete Se deben de tener ciertos cuidados con el uso del operador delete: Debe de estar seguro que se le está aplicando a una dirección de memoria previamente reservada en el Heap. Debe de estar seguro que no tenga el valor de NULL la variable. De no seguir estas indicaciones, el programa terminará incorrectamente. La segunda condición es fácil de validar, sin embargo el evitar caer en la primera es responsabilidad del programador.

Ejemplo Validación if (ptr) delete ptr; De esta manera se asegura que ptr no esté en NULL antes de intentar ejecutar el delete.

El Ámbito de la Memoria Dinámica A diferencia de las variables locales o globales, las variables que residen en memoria dinámica no mueren al finalizar su ámbito, sino que mueren exclusivamente al llamar al operador delete sobre la dirección de memoria donde se encuentran. Es por esto que se dice que trascienden del ámbito.

double* createArray(3) Demostración double* createArray(int s){ double* retVal = NULL; retVal = new double[s]; return retVal; } ... double pd = createArray(3); SS / DS double* createArray(3) 0x3F3A s 3 0x3F12 retVal NULL 0x4CD0 HS 0x4CD0 main() 0x3F12 pd ?? 0x4CD0 ?? 0x4CD8 0x4CE0 0x4CD0

Y… ¿Los arreglos multidimensionales? En el caso de los arreglos multidimensionales dinámicos, tendremos que comprender primero ciertos aspectos de cómo se representan tanto físicamente cómo lógicamente para el compilador. Lo primero que hay que tener claro es que TODOS los arreglos, así como TODOS los objetos de un programa son guardados en la memoria en la forma de un arreglo unidimensional.

Representación de un Arreglo Bidimensional (Física y Lógica) int a[2][3] = {{1,3,5}, {2,4,6}}; Representación Física Representación Lógica a a 1 3 5 2 4 6 5 4 6 4 2 6 4 6 Nótese que la representación lógica, es en sí un arreglo de arreglos, donde a es de tipo int** y a[0], a[1] son de tipo int*

Y, ¿Dinámicamente? Comprendiendo que un arreglo bidimensional es representado en realidad por un arreglo de punteros de la primera dimensión, que a su vez apuntan, cada uno, a un arreglo de la segunda dimensión; podemos crear el procedimiento para la creación dinámica de una “matriz”

Código de Creación y Destrucción de Arreglos Bidimensionales // Estos valores pueden ser introducidos // en tiempo de ejecución int rows = 2, cols = 3; float** matrix; // Se crea el arreglo de punteros matrix = new float*[rows]; for (int i=0; i<rows; i++) matrix[i] = new float[cols];

Acerca del Tamaño de los Punteros El tamaño de los punteros depende directamente de la cantidad de memoria que se desé direccionar. Por ejemplo si sólo necesitamos direccionar 256 bytes, entonces nuestros punteros serían de 1 byte. Si quisieramos direccionar 64KB (65536 Bytes) entonces nuestros punteros serían de 2 bytes. El tamaño de los punteros es independiente del tamaño del objeto al que apuntan. (Probar comparar los tamaños de punteros a char, y punteros a long double)

Retomando Ámbito y Tiempo de Vida Los Objetos Nacen: En el momento de su declaración En el momento que se crean dinámicamente Los Objetos Mueren: En el momento que se acaba su ámbito En el momento que se liberan (delete)