Memoria dinamica
Descargar como PPTX, PDF1 recomendación5,319 vistas
La memoria dinámica permite asignar memoria de forma variable durante la ejecución del programa. Se reserva en la zona libre de memoria principal llamada heap. Su principal ventaja es que el tamaño puede variar, solucionando problemas cuando no se conoce el número de datos por adelantado. El programador es responsable de liberar la memoria dinámica cuando ya no se necesite más mediante funciones como free(), malloc(), calloc() y realloc().
![Veamos un ejemplo en el cual el usuario ingresa una cantidad variable de números por consola. Primero el sistema le pide
que especifiqué la cantidad de números que va a ingresar, y luego de ingresados, los imprime, incrementando en 1 cada
número.
#include <stdio.h>
#include <stdlib.h>
int leercantidad();
void leer(int, int *);
void imprimir(int, int *);
main()
{
int cantidad,*ptr;
cantidad=leercantidad();
ptr=(int *)malloc(cantidad*sizeof(int));//reservo bloques de memoria
leer(cantidad,ptr);
imprimir(cantidad,ptr);
}
int leercantidad()
{
int n;
printf("Cuantos datos quiere ingresar:t");
scanf("%d",&n);
return n;
}
void leer(int n, int *ptr)
{
for(int i=0;i<n;i++)
{
printf("dato [%d]t",i+1);
//scanf("%d",&ptr[i]);
/*scanf("%d",ptr)
ptr++;*/ Mueve el puntero usando la aritmetica
scanf("%d",(ptr+i));//Mueve el puntero referenciado
}
}
void imprimir(int n, int *ptr)
{
for(int i=0;i<n;i++)
{
printf("dato [%d] %dn",i+1,*(ptr+i));
// ptr++;
}
}](https://image.slidesharecdn.com/memoriadinamica-170209175728/85/Memoria-dinamica-17-320.jpg)
![Ejemplo: Vector de tamaño dinámico
#include <stdio.h>
#include <stdlib.h>
float media (float v[], int n)
{
int i;
float suma = 0;
for (i=0; i<n; i++)
suma += v[i];
return suma/n;
}
main()
{
int i;
int n;
float *v;
printf("Número de elementos del vector: ");
scanf("%d",&n);
// Creación del vector
v = malloc(n*sizeof(float));
// Manejo del vector
for (i=0; i<n; i++)
v[i] = i;
printf("Media = %fn", media(v,n));
// Liberación de memoria
free(v);
}](https://image.slidesharecdn.com/memoriadinamica-170209175728/85/Memoria-dinamica-22-320.jpg)
![void *realloc(void *p, size_t size) realloc cambia el tamaño del objeto al que apunta p y lo hace de tamaño
size. El contenido de la memoria no cambiará en las posiciones ya ocupadas. Si el nuevo tamaño es mayor
que el antiguo, no se inicializan a ningún valor las nuevas posiciones. En el caso en que no hubiese
suficiente memoria para “realojar” al nuevo puntero, se devuelve NULL y p no varía. El puntero que se pasa
como argumento ha de ser NULL o bien un puntero devuelto por malloc(), calloc() o realloc().
#define N 10
#include <stdio.h>
main(){
char c, *cambiante;
int i;
i=0;
cambiante = NULL;
printf("nIntroduce una frase. Terminada en [ENTER]n");
while ((c=getchar()) != 'n') {
if (i % N == 0){
printf("nLlego a %d posiciones y pido hasta %d", i, i+N);
cambiante=(char *)realloc((char *)cambiante,(i+N)*sizeof(char));
if (cambiante == NULL) exit(-1);
}
/* Ya existe suficiente memoria para el siguiente carácter*/
cambiante[i++] = c;
}
REALLOC](https://image.slidesharecdn.com/memoriadinamica-170209175728/85/Memoria-dinamica-40-320.jpg)
Memoria dinamica
- 2. INTRODUCCION
- 3. DATOS EN MEMORIA Datos estáticos: Su tamaño y forma es constante durante la ejecución de un programa y por tanto se determinan en tiempo de compilación. El ejemplo típico son los arrays. Tienen el problema de que hay que dimensionar la estructura de antemano, lo que puede conllevar desperdicio o falta de memoria. Datos dinámicos: Su tamaño y forma es variable (o puede serlo) a lo largo de un programa, por lo que se crean y destruyen en tiempo de ejecución. Esto permite dimensionar la estructura de datos de una forma precisa: se va asignando memoria en tiempo de ejecución según se va necesitando.
- 4. ASPECTOS A CONSIDERAR PARA EL USO DE MEMORIA DINAMICA • 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, C++ y le da la capacidad de crear programas complejos que emplean grandes cantidades de memoria y los maneja de manera eficiente.
- 5. Memoria dinámica Es memoria que se reserva en tiempo de ejecución. Su principal ventaja frente a la estática, es que su tamaño puede variar durante la ejecución del programa. (En C, el programador es encargado de liberar esta memoria cuando no la utilice más). El uso de memoria dinámica es necesario cuando a priori no conocemos el número de datos/elementos a tratar. Cuando el sistema operativo carga un programa para ejecutarlo y lo convierte en proceso, le asigna cuatro partes lógicas en memoria principal: texto, datos (estáticos), pila y una zona libre. Esta zona libre (o heap) es la que va a contener los datos dinámicos, la cual, a su vez, en cada instante de la ejecución tendrá partes asignadas a los mismos y partes libres que fragmentaran esta zona, siendo posible que se agote si no se liberan las partes utilizadas ya inservibles. (La pila también varia su tamaño dinámicamente, pero la gestiona el sistema operativo, no el programador):
- 6. • 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. • 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 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(). MEMORIA DINAMICA
- 7. • Las regiones de memoria que reservan/liberan estas funciones son almacenadas en el montículo o heap. MEMORIA DINAMICA
- 8. • 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. ASIGNACION DINAMICA DE MEMORIA
- 9. ASIGNACION DINAMICA DE MEMORIA 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).
- 11. Stdlib.h
- 13. Malloc()
- 14. IMPORTANTE
- 17. Veamos un ejemplo en el cual el usuario ingresa una cantidad variable de números por consola. Primero el sistema le pide que especifiqué la cantidad de números que va a ingresar, y luego de ingresados, los imprime, incrementando en 1 cada número. #include <stdio.h> #include <stdlib.h> int leercantidad(); void leer(int, int *); void imprimir(int, int *); main() { int cantidad,*ptr; cantidad=leercantidad(); ptr=(int *)malloc(cantidad*sizeof(int));//reservo bloques de memoria leer(cantidad,ptr); imprimir(cantidad,ptr); } int leercantidad() { int n; printf("Cuantos datos quiere ingresar:t"); scanf("%d",&n); return n; } void leer(int n, int *ptr) { for(int i=0;i<n;i++) { printf("dato [%d]t",i+1); //scanf("%d",&ptr[i]); /*scanf("%d",ptr) ptr++;*/ Mueve el puntero usando la aritmetica scanf("%d",(ptr+i));//Mueve el puntero referenciado } } void imprimir(int n, int *ptr) { for(int i=0;i<n;i++) { printf("dato [%d] %dn",i+1,*(ptr+i)); // ptr++; } }
- 20. Crear un programa que lea una línea de caracteres, reserva memoria para un buffer de tantos caracteres como leídos y se copia en el buffer la cadena ingresada: Ejemplo
- 21. Crear un programa que cree un array de N valores de tipo entero de forma dinámica
- 22. Ejemplo: Vector de tamaño dinámico #include <stdio.h> #include <stdlib.h> float media (float v[], int n) { int i; float suma = 0; for (i=0; i<n; i++) suma += v[i]; return suma/n; } main() { int i; int n; float *v; printf("Número de elementos del vector: "); scanf("%d",&n); // Creación del vector v = malloc(n*sizeof(float)); // Manejo del vector for (i=0; i<n; i++) v[i] = i; printf("Media = %fn", media(v,n)); // Liberación de memoria free(v); }
- 27. Matrices Dinámicas Realice un programa que genere una matriz de n filas y n columnas, muestre el resultado utilizando el formato de array y el de puntero:
- 28. Practica UTILIZANDO MEMORIA DINAMICA REALICE EL SIGUIETE EJERCICIO MENU 1 DIAGONAL PRINCIPAL 2 DIAGONAL SECUNDARIA 3 COMBINAR DIAGONALES 4 SALIR CREAR LAS FUNCIONES LLENAR DIAGONAL_PRINCIPAL DIAGONAL_SECUNDARIA COMBINAR_DPDS
- 33. - void *malloc(size_t size); - void *calloc(size_t nmemb, size_t size); malloc() Con esta función obtenemos el puntero que nos da la dirección del bloque de memoria reservado dinámicamente. Sin embargo, malloc() no inicializa el contenido de este bloque de memoria. calloc() Cumple la misma función que malloc(), con una diferencia: calloc() si inicializa a 0 el contenido de cada elemento del array dinámico. Se puede apreciar como en la definición de calloc() el primer parámetro es el nº de elementos y a continuación el tamaño del elemento (por ejemplo para int: sizeof(int)). Mientras que en malloc() debíamos pasarle el tamaño del bloque entero, es decir: "nºelementos*tamaño de elemento".
- 39. Esta función posee una gran utilidad, pues es la que nos sirve para redimensionar nuestro bloque de memoria (array, etc) generado dinámicamente. Sus parámetros son: el puntero a redimensionar y el nuevo tamaño, que al igual que en malloc() será: "nº elementos*tamaño de elemento". Esta función guarda el contenido que tengamos almacenado en el bloque de memoria a redimensionar. En el caso de que lo hagamos mas pequeño elimina el contenido sobrante. En caso de que al redimensionar no exista espacio consecutivo para el nuevo bloque realloc() cambia de lugar nuestro bloque y nos devuelve el puntero a la nueva dirección. Es por esto por lo que siempre deberemos guardar el puntero obtenido con esta función.
- 40. void *realloc(void *p, size_t size) realloc cambia el tamaño del objeto al que apunta p y lo hace de tamaño size. El contenido de la memoria no cambiará en las posiciones ya ocupadas. Si el nuevo tamaño es mayor que el antiguo, no se inicializan a ningún valor las nuevas posiciones. En el caso en que no hubiese suficiente memoria para “realojar” al nuevo puntero, se devuelve NULL y p no varía. El puntero que se pasa como argumento ha de ser NULL o bien un puntero devuelto por malloc(), calloc() o realloc(). #define N 10 #include <stdio.h> main(){ char c, *cambiante; int i; i=0; cambiante = NULL; printf("nIntroduce una frase. Terminada en [ENTER]n"); while ((c=getchar()) != 'n') { if (i % N == 0){ printf("nLlego a %d posiciones y pido hasta %d", i, i+N); cambiante=(char *)realloc((char *)cambiante,(i+N)*sizeof(char)); if (cambiante == NULL) exit(-1); } /* Ya existe suficiente memoria para el siguiente carácter*/ cambiante[i++] = c; } REALLOC