Repaso 02: Apuntadores y manejo de memoria dinámica

Transcripción

1 Repaso 02: Apuntadores y manejo de memoria dinámica Solicitado: Ejercicios 02: Programación con memoria dinámica M. en C. Edgardo Adrián Franco Martínez edgardoadrianfrancom Estructuras de datos (Prof. Edgardo A. Franco) 1

2 Contenido Memoria de un proceso Apuntadores Dirección de memoria Definición de apuntador Manejo de memoria dinámica Sentencia malloc() Sentencia free() Problema Solución en C Ejercicio 02: Programación con memoria dinámica 2

3 Memoria de un proceso Durante la ejecución del proceso, todos los datos manipulados (incluido el propio código del programa compilado) se alojan en la memoria principal, ya que esta ofrece menor latencia (menor tiempo de comunicación con el CPU) respecto de los medios secundarios. 3

4 Empezando por la direcciones más bajas, el segmento de código es la porción de la memoria donde se carga el programa que se ejecuta. El segmento de datos alberga las declaraciones globales (e.g. variables del programa principal y constantes globales). El montículo es la región de memoria que se toma y se libera de manera dinámica durante la ejecución del programa. La pila es donde se "apilan" porciones de memoria pertenecientes a funciones y/o procedimientos cuando se les llama. 4

5 Código Datos Memoria de proceso activo Montículo (Heap) Pila Pila (Stack) 5

6 0xFFFFFFH Direcciones más bajas 0x0000AAH 6

7 Apuntadores Los apuntadores o punteros son otro tipos de dato que se utilizan en lenguaje de programación como C. Permiten el acceso a memoria (memoria del proceso) de manera más eficiente, sin embargo, una mala referencia a dicha memoria provocará en el programa una salida inesperada. 7

8 Trabajar con apuntadores implica la no manipulación de variables en sí, sino manejar direcciones de memoria en la cuales residen los datos. Una variable apuntador o puntero, es una variable que contiene direcciones de otras variables o instrucciones, es decir, almacenan la dirección de memoria donde se encuentran los datos asociados a dichas variables o instrucciones. 8

9 Dirección de memoria Cuando una variable se declara, se le asocian tres atributos fundamentales a dichas variables: su identificador, su tipo de dato y su dirección de memoria. por ejemplo: int n; identificador n 0x4fffd34 int 1234 tipo de dato dirección de memoria valor de la variable 9

10 Definición de apuntador Cuando se declara una variable de tipo apuntador, el compilador también le asigna una dirección de memoria, sin embargo, en esa localidad de memoria no se almacena un tipo de dato simple, sino la dirección de una variable del mismo tipo que se declaro el apuntador, es decir: int variable = 30; int *ptr = &variable; 10

11 Los apuntadores en C se rigen por la siguientes reglas básicas: 1. Un apuntador es una variable como cualquier otra; 2. Una variable apuntador contiene una dirección que apunta a otra posición de memoria; 3. En esa posición de memoria se almacenan los datos a los que apunta el apuntador; 4. Un apuntador apunta a una variable que se encuentra almacenada en alguna parte de la memoria del programa, pudiendo ser esta una variable que apunte a otra localidad de memoria. (Dobles apuntadores, ) 5. Un apuntador común de C debe almacenar direcciones validas para el programa si se realiza una operación de dirección (*) sobre este, se puede causar un error de programa al intentar acceder a direcciones invalidas para el programa. 11 Estructuras de datos (Prof. Edgardo A. Franco)

12 Manejo de memoria dinámica Una variable global, del programa principal o de una función comparte una característica en común, se definen cuando se compila el programa. Esto significa que el compilador indica el espacio en memoria de datos y/o pila 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 memoria de trabajo de estas funciones son almacenadas en el montículo o heap. 12

13 Cuando se declara una variable global o principal en C, el compilador establece un área de memoria de datos para almacenar el contenido de la variable, cuando se hacer referencia a dicha variable, el programa accede automáticamente a la dirección de memoria donde se almacena el contenido la variable para poder utilizarla. Si la variable es local de una función, el compilador agrega las instrucciones necesarias para que el programa al ingresar a la función coloque dichas variables en la región de la pila de su memoria asignada para acceder a ellas. 13

14 14

15 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 15

16 La forma de utilizar la función malloc() es: donde: apuntador = (tipo *)malloc(tamanio en bytes); apuntador: es el apuntador que almacenará la referencia o apuntara al bloque de memoria generado. tipo *: es el cast a un apuntador valido para manejar los datos que se van a almacenar en el bloque de memoria asignado. tamanio: es el tamaño en bytes del bloque de memoria que se va a reservar. 16

17 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 } 17

18 Función sizeof() y malloc() 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) ); 18

19 Uso de malloc() para generar un arreglo bidimensional 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. 19

20 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( num_filas* sizeof(int *) ); 2. Se solicita memoria para almacenar el numero de elementos que va a formar cada fila o arreglo unidimensional (columnas). arr2d[i] = (int*)malloc( columnas * sizeof( int ) ); 20

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

22 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 del programa. 22

23 Problema Escribir una programa en C que reciba (por la entrada estándar) los valores de m (filas) y n (columnas) y genere una matriz dinámica de enteros, posteriormente la matriz será llenada por el usuario (entrada estándar) y se llamará a intercambia_filas() que intercambiará la fila i-esima por la j- esima (i y j se introducen por la entrada estándar), finalmente el programa mostrara la matriz resultante llamando a imprime_matriz(). 23

24 Problema (Declaración de funciones) //DECLARACIÓN DE FUNCIONES //Aparta el espacio de memoria para la matriz dinámica int **Aparta_Matriz(int m,int n); //Capturar la matriz dinámica void Capturar_Matriz(int **matriz,int m,int n); //Intercambia la fila i-esima por la j-esima de la matriz void Intercambia_Filas(int **matriz,int i,int j); //Imprime la matriz dinámica void Imprime_Matriz(int **matriz,int m,int n); 24

25 Problema (Programa principal) //PROGRAMA PRINCIPAL int main(void) { int m,n,**matriz; int i,j; //Leer m y n printf("\nintroduce m y n separados por espacio o enter: "); scanf("%d %d",&m,&n); //Apartar espacio para la matriz matriz=aparta_matriz(m,n); //Llenar la matriz de datos Capturar_Matriz(matriz,m,n); //Mostrar la matriz printf("\n***matriz Original***"); Imprime_Matriz(matriz,m,n); //Leer i y j (Filas a intercambiar) printf("\nintroduce las filas i y j a intercambiar separados por espacio o enter: "); scanf("%d %d",&i,&j); //Intercambiar filas i y j Intercambia_Filas(matriz,n,i,j); //Mostrar la matriz printf("\n***matriz Modificada***"); Imprime_Matriz(matriz,m,n); } 25

26 Problema (Apartar memoria para la matriz) /* int **Aparta_Matriz(int m,int n); Descripción: Aparta el espacio de memoria para la matriz dinámica Recibe: int m (Número de filas), int n (Número de columnas) Devuelve: int **matriz (Referencia a la matriz apartada), Observaciones: m y n deberan ser mayor a 0 */ int **Aparta_Matriz(int m,int n) { int i, **matriz; //Apartar memoria para la matriz matriz=malloc(m*sizeof(int)); //m apuntadores simples a enteros for(i=0;i<m;i++) matriz[i]=malloc(n*sizeof(int)); //El apuntador simple matriz[i] apunta a n enteros return matriz; la matriz dinámica } //Regresa la referencia al apuntador principal a 26

27 Problema (Capturar la matriz) /* void Capturar_Matriz(int **matriz,int m,int n); Descripción: Capturar la matriz dinámica Recibe: int **matriz (Referencia a la matriz), int m (Número de filas), int n (Número de columnas) Devuelve: Observaciones: La matriz fue reservada previamente de tamaño m por n */ void Capturar_Matriz(int **matriz,int m,int n) { int i,j; for(i=0;i<m;i++) for(j=0;j<n;j++) { printf("\nintroduce el elemento[%d][%d]: ",i,j); scanf("%d",&matriz[i][j]); } } 27

28 Problema (Mostrar la matriz) /* void Imprime_Matriz(int **matriz,int m,int n); Descripción: Procedimiento para imprimir la matriz Recibe: int **matriz (Referencia a la matriz), int m (Número de filas), int n (Número de columnas) Devuelve: Observaciones: La matriz fue reservada previamente de tamaño m por n */ void Imprime_Matriz(int **matriz,int m,int n) { int i,j; for(i=0;i<m;i++) { printf("\n"); for(j=0;j<n;j++) printf("%d\t",matriz[i][j]); } } 28

29 Problema (Intercambiar filas de la matriz) /* void Intercambia_Filas(int **matriz,int n,int i,int j); Descripción: Procedimiento para intercambiar filas i y j de la matriz Recibe: int **matriz (Referencia a la matriz), int n (Número de columnas) int i e int j (Filas a intercambiar) Devuelve: Observaciones: La matriz fue reservada previamente de tamaño m por n */ void Intercambia_Filas(int **matriz,int n,int i,int j) { int x,aux,*aux2; //Manera 1 (Cambiando de fila cada uno de los datos) /*for(x=0;x<n;x++) { aux=matriz[j][x]; matriz[j][x]=matriz[i][x]; matriz[i][x]=aux; }*/ } //Manera 2 (Cambiando solo los apuntadores a cada fila) aux2=matriz[i]; //Se puede escribir coomo aux2=*(matriz+i); matriz[i]=matriz[j];//se puede escribir coomo *(matriz+i)=*(matriz+j); matriz[j]=aux2; //Se puede escribir coomo *(matriz+j)=aux2; 29

30 Ejercicios 02: Programación con memoria dinámica Programa de manera estructurada en ANSI C, un programa capaz de generar y recibir dos matrices dinámicas de tamaño m por n, donde m y n ingresan por la entrada estándar, además de los valores de las matrices, el programa realiza una operación de suma y resta de matrices que se muestra por la salida estándar. Observaciones 1. Construir un código modular (no todo en el main) y debidamente documentado. 2. Entregar un reporte con las explicaciones de cada prueba). pruebas (capturas de pantalla y 3. El reporte es individual y tiene portada, índice y encabezados de pagina con número de pagina, titulo y nombre del alumno. 4. Enviar vía Web en un archivo comprimido (ZIP, RAR o TAR), código y reporte. *Se entregará antes del día Lunes 22 de Agosto de 2016 (23:59:59 hora limite). 30