Tema 18: Memoria dinámica y su uso en C

Transcripción

1 Tema 18: Memoria dinámica y su uso en C M. en C. Edgardo Adrián Franco Martínez edgardoadrianfrancom Estructuras de datos (Prof. Edgardo A. Franco) 1

2 Introducción En muchas ocasiones no es posible conocer de antemano la cantidad de variables necesarias para un programa computacional. Existen aplicaciones que requieren de enormes cantidades de arreglos o datos por momentos breves en el funcionamiento del mismo, por lo que no es viable declarar de antemano a estas como variables, globales o locales de una función. Lo anterior implica emplear funciones de ANSI C que permiten reservar memoria de manera dinámica y ampliarla, reducirla o destruirla en tiempo de ejecución. El manejo de memoria dinámica es la base del poder del lenguaje C y le da la capacidad de crear programas complejos que emplean grandes cantidades de memoria y los maneja de manera eficiente. 2

3 Todos los programas definen variables que pueden ser definidas como globales y locales. Las variables globales y del programa principal (main) se almacenan en posiciones fijas de la memoria llamada memoria de datos. Las variables locales se almacenan en el segmento de memoria llamada pila y existen solo cuando se hace una invocación a la función que las declaro. También se pueden declarar variables estáticas locales que también se almacenan en segmentos fijos de memoria o en la memoria de datos, sin embargo, también están disponibles en la función que las declaro. 3

4 Todas estas variables comparten una característica en común, se definen cuando se compila el programa. Esto significa que el compilador reserva espacio en memoria para almacenar los valores para estas variables. Sin embargo, no todas las veces es posible conocer el numero de variables con el que va a constar nuestro programa. C ofrece al desarrollador la opción de crear diferentes tipos de variables de forma dinámica, para crear tales variables se utilizan funciones como: malloc(), realloc(), calloc(), y free(). Las regiones de memoria que reservan/liberan estas funciones son almacenadas en el montículo o heap. 4

5 Memoria de proceso activo Código (Main y código de funciones empleadas) Datos (Variables globales y declaradas dentro del main) Pila (Stack) (Variables y datos de las funciones al estar en ejecución) Pila Montículo (Heap) (Variables dinámicas del programa) 5

6 Asignación dinámica de memoria Por lo regular cuando se diseña un algoritmo, se debe conocer que elementos de entrada tendrá y cual será la salida, sin embargo, en algunas ocasiones no se sabe de forma exacta el numero de variables que requerirá nuestro algoritmo. Por ejemplo, suponga que se van a registrar el numero de calificaciones de un conjunto de alumnos, para resolver este problema se podría utilizar una arreglo de calificaciones, sin embargo, si el numero de alumnos crece, nuestro programa ya no seria valido, puesto que no existen los recursos necesarios para almacenar todos los datos validos. Para resolver este problema es necesario recurrir al uso de apuntadores y a la asignación dinámica de memoria. 6

7 El espacio de memoria asignado a una variable generada de manera dinámica se crea durante la ejecución del programa (tiempo de ejecución), al contrario de las variables declaradas en código, que el espacio de memoria se les asigna en tiempo de compilación. Una variable que es generada dinámicamente, se construye (por ejemplo con malloc) y se puede destruir en tiempo de ejecución (uso de free). 7

8 Recordatorio: Las instrucciones de un programa compilado se sitúan en segmentos de memoria denominado segmento de código (memoria de programa). Los datos del programa, tales como variables globales, se almacenan en un área denominado segmento de datos. Las variables locales y el respaldo de los registros de control del programa se sitúan en el segmento llamado pila. Y cuando un programa solicita memoria dinámica para una variable, se le asigna memoria del segmento denominado montículo o heap. 8

9 Función malloc() malloc() es la forma más habitual de obtener bloques de memoria dinámica. La función genera o asigna un bloque de memoria que es el numero de bytes pasados como argumento. malloc() devuelve un apuntador void* al bloque de memoria asignado, por lo tanto, hay que realizar un cast al tipo de apuntador requerido, para hacer buen uso de la memoria o de los datos que se lleguen a almacenar en dicho bloque de memoria. Nota: Todas las funciones de asignación dinámica de memoria se encuentran definidas en la biblioteca stdlib.h 9

10 El prototipo de la función malloc() sería: Donde: void* = malloc( size_t bytes); void*: es el apuntador que almacenará la referencia o apuntara al bloque de memoria generado. bytes: es el tamaño en bytes del bloque de memoria que se va a solicitar. 10

11 Por ejemplo: #include <stdio.h> #include <stdlib.h> int main( void ){ char *c; int *entero; float *flotante; double *doble; //Uso de malloc para generar variables sencillas c = (char *)malloc( 1 ); entero = (int *)malloc( 4 ); flotante = (float *)malloc( 4 ); doble = (double *)malloc( 8 ); *c = 'a'; *entero = 10; *flotante = ; *doble = ; //otra forma de generar la memoria //dinámica seria: c = (char *)malloc( sizeof(char) ); entero = (int *)malloc( sizeof(int) ); flotante = (float *)malloc( sizeof(float) ); doble = (double *)malloc( sizeof(double) ); *c = 'c'; *entero = 2378; *flotante = ; *doble = ; printf( "valores: caracter %c, entero %d, flotante %f, doble %lf", *c, *entero, *flotante, *doble ); free( c ); free( entero ); free( flotante ); free( doble ); return 0; } printf( "valores: caracter %c, entero %d, flotante %f, doble %lf \n\n", *c, *entero, *flotante, *doble ); //Importantísimo liberar la memoria //cuando ya no es requerida free( c ); free( entero ); free( flotante ); free( doble ); 11

12 La función sizeof se utiliza con mucha frecuencia para referirnos al tamaño de memoria que se va a generar por las funciones de memoria dinámica. Por ejemplo, si se requiere reservar un bloque de memoria para un arreglo de 10 enteros: int *ptr; ptr = (int *)malloc( 10 * sizeof(int) ); Al llamar a malloc() puede ser que no haya suficiente memoria disponible, entonces, malloc() devolverá NULL en la operación, por lo tanto, siempre es conveniente preguntar después de la operación si se asigno el bloque de memoria. int *ptr; ptr = (int *)malloc( 10 * sizeof(int) ); if( ptr == NULL){ printf( "No hay memoria disponible \n" ); //no utilizar ptr return; //fin del programa o realizar la acción conveniente } //utilizar ptr 12

13 Si no se conoce el tamaño de memoria que se quiere reservar al momento de diseñar un algoritmo, dicho tamaño se puede solicitar al usuario y generar el bloque de memoria en tiempo de ejecución. Un pequeño ejemplo seria el siguiente: int tam; int *ptr; printf( "Ingresa el tamaño del arreglo " ); scanf( "%d", &tam; ); ptr = (int *)malloc( tam * sizeof(int) ); Nota importante: Los apuntadores que se utilizan para hacer referencia al bloque de memoria asignado por malloc() son de tipo dinámico y NO es conveniente que dichos apuntadores apunten a otro lugar antes de liberar el bloque de memoria asignado ya que se estará perdiendo la referencia al bloque de memoria y no abra forma de recuperar la referencia ha esta, por lo tanto, la memoria no será liberada y hasta finalizar el programa. 13

14 Un arreglo bidimensional en realidad es un arreglo cuyos elementos son arreglos. Si el nombre de un apuntador unidimensional es un apuntador sencillo, entonces, el nombre de un arreglo bidimensional será un apuntador a apuntadores sencillos. Para asignar memoria a un arreglo multidimensional, se indica cada dimensión del arreglo al igual que se declara un arreglo unidimensional. 14

15 Uso de malloc() para generar un arreglo bidimensional Para generar al arreglo bidimensional utilizando memoria dinámica se hace en dos pasos: 1. Se solicita la memoria para crear un arreglo de apuntadores que van a apuntar a cada fila del arreglo. int **arr2d = (int *)malloc( 10 * sizeof(int *) ); 1. Se solicita memoria para almacenar el numero de elementos que va a formar cada fila o arreglo unidimensional. 15 arr2d[i] = (int*)malloc( elemfilas * sizeof( int ) );

16 arr2d arr2d[0] arr2d[1] arr2d[2] arr2d[3] arr2d[4] arr2d[5] arr2d[6] Arreglo de apuntadores sencillos Arreglos unidimensionales de tamaño n arr2d[7] arr2d[8] arr2d[9] Donde cada arr2d[i] es un apuntador sencillo que apunta a un arreglo unidimensional de tamaño n. 16

17 #include <stdio.h> #include <stdlib.h> int main(){ int **arr2d, **aux; int tamfilas, elemfilas,i,j; int tam; do{ system( "cls" ); printf( "Ingresa el numero de filas: " ); scanf( "%d", &tamfilas ); }while(!(tamfilas > 0) ); arr2d = (int**)malloc( tamfilas * sizeof( int* ) ); aux = arr2d; //para asignar el tamaño de cada una de las filas o arreglos //unidimensionales for( i = 0; i < tamfilas; i++ ){ do{ printf( "Ingresa un valor valido de elementos de una fila: " ); scanf( "%d", &elemfilas ); }while(!(elemfilas > 0) ); //dos formas para generar los arreglos unidimensional //de elementos //1.- arr2d[i] = (int*)malloc( elemfilas * sizeof( int ) ); //2.- /* *aux = (int*)malloc( elemfilas * sizeof( int ) ); aux++;*/ //asignar valores a cada arreglo arr2d[i] srand( time(null) ); for( j=0; j<elemfilas; j++ ){ arr2d[i][j] = rand()%100; } } } //imprimir los valores for( j=0; j<elemfilas; j++ ){ printf( "%d ", arr2d[i][j] ); } printf( "\n"); //liberar la memoria for(i=0; i<tamfilas; i++ ){ free( arr2d[i] ); } free( arr2d ); return 0; 17

18 Uso de free() para liberar la memoria asignada dinámicamente Cuando se termina de utilizar un bloque de memoria previamente asignado por cualquier función de asignación dinámica de memoria, se debe liberar el espacio de memoria y dejarlo disponible para otros procesos, esto se realiza utilizando la función free(). El prototipo la función free es: void free(void *ptr); Donde: *ptr es el apuntador que hace referencia al bloque de memoria asignado, si ptr es NULL entonces free no hace nada. Si embargo, si ptr es un apuntador mal referenciado, el uso de free probablemente destruya el mecanismo de gestión de memoria y provocará un fallo en la aplicación. 18

19 Función calloc() calloc() es otra función que permite obtener memoria dinámica. Al igual que malloc() devuelve un apuntador void* que hace referencia al bloque de memoria generado o NULL si no existe memoria suficiente para generar el bloque solicitado, por tal motivo, también es necesario realizar un cast a un apuntador valido para manejar los datos que se van a almacenar en el bloque de memoria asignado. 19

20 El prototipo de la función calloc() es: void* calloc( size_t n, size_t t ); Donde: n: es el numero de datos que se van a almacenar en la memoria. t: es el tamaño de cada elemento, es decir, el tamaño del tipo de dato. 20

21 Función calloc() Forma de uso: puntero = (tipo*) calloc( numelem, tamelem ); Donde: puntero: es un apuntador valido que hace referencia al bloque de memoria generado. tipo *: es el cast al un apuntador valido. numelem: es el numero de elementos que se van a almacenar en el bloque de memoria. tamelem: es el tamaño del tipo de dato que se va a almacenar en la memoria. calloc() una cantidad de memoria igual a numelem * tamelem. Es decir, calloc() asigna memoria suficiente para un arreglo que contiene numelem elementos con un tamaño tamelem cada uno. Por ejemplo: int *ptr; ptr = (int *)calloc( 10, sizeof(int) ); 21

22 Ejemplo: #include <stdio.h> #include <stdlib.h> int main( void ){ char *c; int *entero; float *flotante; double *doble; c = (char *)calloc( 1,1 ); entero = (int *)calloc( 1,4 ); flotante = (float *)calloc( 1,4 ); doble = (double *)calloc( 1,8 ); *c = 'a'; *entero = 10; *flotante = ; *doble = ; //otra forma de generar la memoria //dinamica seria: c = (char *)calloc( 1, sizeof(char) ); entero = (int *)calloc( 1, sizeof(int) ); flotante = (float *)calloc( 1, sizeof(float) ); doble = (double *)calloc( 1, sizeof(double) ); *c = 'c'; *entero = 2378; *flotante = ; *doble = ; printf( "valores: caracter %c, entero %d, flotante %f, doble %lf", *c, *entero, *flotante, *doble ); free( c ); free( entero ); free( flotante ); free( doble ); return 0; } printf( "valores: caracter %c, entero %d, flotante %f, doble %lf \n\n", *c, *entero, *flotante, *doble ); //Importantisimo liberar la memoria //cuando ya no es requerida free( c ); free( entero ); free( flotante ); free( doble ); 22

23 Función realloc() realloc() es la tercera función para obtener memoria dinámica. También devuelve un apuntador void* que hace referencia al bloque de memoria por lo tanto necesario realizar un cast a un apuntador valido. A diferencia de malloc() y calloc(), realloc() cambia el tamaño de un bloque de memoria asignado dinámicamente, es decir, toma como parámetro de entrada un apuntador *ptr a esa memoria y dependiendo de un segundo parámetro incrementará o reducirá el tamaño de dicho bloque de memoria. 23

24 El prototipo de la función es: void* realloc(void* ptr, size_t t); Donde: ptr: es el apuntador que hace referencia a un bloque de memoria generado dinámicamente. t: es el nuevo tamaño en bytes para el bloque de memoria referenciado por ptr. t pude ser mayor o menor que el bloque original. Se devuelve un apuntador debido a que puede que realloc() tenga que desplazar el bloque original para poder modificar su tamaño. Si este es el caso, se copia la información del bloque original (hasta t bytes) en el nuevo bloque. 24

25 Forma de uso: puntero = (tipo*) realloc( ptr, nuevotam ); Donde: puntero: es un apuntador valido que hace referencia al bloque de memoria generado. tipo *: es el cast al un apuntador valido. ptr: el apuntador que hace referencia a un bloque de memoria generado dinámicamente. nuevotam: es el nuevo tamaño para el bloque de memoria referenciado por ptr. 25

26 Hay que tener en cuanta varias consideraciones al utilizar la función realloc(): 1. En el C99 se especifico que la memoria referenciada por ptr se libera y se crea un nuevo bloque. 2. El nuevo bloque contiene la misma información que el bloque original (hasta la longitud especificada por nuevotam). Se regresa un apuntador al nuevo bloque de memoria, sin embargo, el compilador puede generar el nuevo bloque a partir de la misma dirección de inicio del bloque anterior, es decir, el nuevo bloque puede contener la misma dirección de inicio que el bloque anterior. 26

27 3. Si ptr es NULL, realloc() simplemente genera el bloque de memoria especificado por nuevotam. Si nuevotam es cero, se libera la memoria referenciada por ptr y la función devuelve NULL. 4. Si no hay memoria suficiente para asignar nuevotam bytes, realloc() devuelve un apuntador NULL y el bloque original permanecerá intacto. 27