Asignación de memoria dinámica en C

En DMA, la decisión sobre los recuerdos que se asignan no puede tomar durante el tiempo de compilación. Esta decisión o memoria se asigna durante el tiempo de ejecución.

Cada vez que creamos ninguna variable a través de DMA, ese tipo de variables no tiene ningún nombre; Accedemos a estas variables a través de la dirección o el puntero.

En SMA, el programador sabe desde el momento anterior cuántas variables o cuántos recuerdos se requieren para su programa.

Pero en DMA, el programador no sabe por estado anterior que se requieren cuántas variables o memoria, depende del requisito del usuario.

Tipos de DMA:

1. malloc ()
2. calloc ()
3. REALLOC ()
4. Gratis ()

malloc ()

La función MALLOC () es una declaración de acción cuando el compilador lee esta línea. El compilador no comprende cuántos recuerdos se asigna, ya que es una declaración de acción. En el bloque de memoria de tiempo de ejecución se crea.

Cada vez que llamamos a malloc () pasamos un número como argumento, que puede entender el número de bytes de bloque de memoria debe ser creado por el malloc (). En malloc (), no puede declarar ningún tipo de datos. Malloc () siempre devuelva la dirección, qué bloque de memoria se crea.

El tipo de retorno de malloc () es un puntero vacío porque no sabe qué tipos de dirección devuelve. Para esto tenemos que escribir casta.

P = (float*) malloc (4);

Aquí escribimos casta, porque malloc () es un puntero vacío.

Ejemplo 1:

#incluir
#incluir
#Define nulo 0
int main ()

int *a, *t;
tamaño int;
printf ("¿Cuál es el tamaño de la mesa? ? ");
scanf ("%d" y tamaño);
printf ("\ n");
if ((t = (int *) malloc (size * sizeof (int))) == nulo)

printf ("No hay espacio disponible \ n");
salida (1);

printf ("\ n dirección del primer byte es %u \ n", t);
/* Lectura de valores de la tabla*/
printf ("\ n valores de la tabla de entrada \ n");
para (a = t; a < t + size ; a++ )
scanf ("%d", a);
/* Valores de la tabla de impresión en orden inverso*/
para (a = t + tamaño - 1; a> = t; a -)
printf (" %d se almacena en la dirección %u \ n", *a, a);
gratis (t);
regresar 0;

Producción:

Calloc ():

Con la ayuda de Calloc () podemos crear más de un bloque o matriz en Calloc (pasamos dos argumentos; el primero es cuántos bloques queremos crear y el segundo es el tamaño del bloque). calloc () también devuelve la dirección en cada bloque por predeterminado 0 es existente.

Ejemplo-2:

#incluir
#incluir
int main ()

int *n, *freq, i, tamaño;
printf ("¿Cuál es el tamaño de la lista? ? ");
scanf ("%d" y tamaño);
n = (int *) malloc (size * sizeOf (int));
printf ("Ingrese los números:");
para (i = 0; i < size ; i++ )

printf ("\ n Ingrese el num [%d]:", i);
scanf ("%d", & n [i]);
if (n [i] < 0 || n [ i ] > 4)

printf ("El número de \ n debe estar dentro del rango (0-4)");
i-- ;
continuar ;


freq = (int *) calloc (5, sizeof (int));
para (i = 0; i < size ; i++ )
Freq [n [i]] ++;
printf ("\ n las frecuencias de los números son:");
para (i = 0; i < 5 ; i++ )
printf ("\ n freq [ %d] = %d", i, freq [i]);
printf ("\ n");
gratis (freq);
regresar 0;

Producción:

REALLOC ()

Cada vez que creamos un bloque con la ayuda de malloc () o calloc () y queremos cambiar o cambiar el tamaño del bloque, usamos REALLOC ().

Void *reasLoc (void *bloque, tamaño int)

En REALLOC () Tenemos que pasar la dirección como un argumento desde el cual queremos cambiar el tamaño.

REALELOC (PTR, 8);

y el tamaño del bloque que queremos cambiar el tamaño. Ese tamaño tenemos que pasar un argumento en REALLOC ().

doble *q;
Q = REALLOC (PTR, 8);

Solo aquellos bloques creados por malloc () o calloc () pueden cambiar el tamaño de REALLOC ().

Ejemplo-3:

#incluir
#incluir
#incluir
#Define nulo 0
int main ()

Char *búfer;
/ * Asignación de memoria */
if ((buffer = (char *) malloc (10)) == nulo)

printf ("Malloc falló. \ n ");
salida (1);

printf ("búfer de tamaño %d creado \ n", sizeOf (buffer));
strcpy (búfer, "hyderabad");
printf ("\ n buffer contiene: %s \ n", búfer);
/ * Reasignación */
if ((buffer = (char *) reasLoc (buffer, 15)) == null)
printf ("La reasignación falló. \ n ");
salida (1);

printf ("\ n tamaño de búfer modificado. \ n ");
printf ("\ n buffer todavía contiene: %s \ n", búfer);
strcpy (búfer, "Secunderabad");
printf ("\ n buffer ahora contiene: %s \ n", búfer);
/ * Memoria de liberación */
gratis (búfer);
regresar 0;

Producción:

gratis ()

Con la ayuda de Free (), liberamos el bloque de memoria creado por MALLOC () o Calloc () o RealLoc ().

Las variables estáticas solo existen en el alcance del bloque o una función. Si no podemos ejecutar el Free (), siempre que se destruya la variable estática P, la variable que se crea dinámicamente, que no se destruye, pero permanece para siempre en RAM o en la memoria. Esto se llama fuga de memoria. Para este gratis () se requiere para destruir el bloque de memoria que se crea dinámicamente.

Gratis () solo destruye la memoria que se crea dinámicamente.

Conclusión:

DMA es un concepto poderoso en el lenguaje C porque elimina el inconveniente de la SMA. En SMA tenemos que tomar una decisión antes de ejecutar el programa de cuántos bloques de memoria se crean. Como resultado, la memoria se desperdicia o la memoria no es suficiente. DMA resuelve el problema tomando la decisión en el tiempo de ejecución que se requieren cuántos bloqueos se requieren para asignar memoria. Asigna memoria al requisito del programa.