Allocation de mémoire dynamique en c

Dans le DMA, la décision sur les souvenirs alloués ne peut pas prendre pendant le temps de compilation. Cette décision ou cette mémoire est allouée pendant l'exécution.

Chaque fois que nous créons une variable via DMA, ce type de variables n'a aucun nom; Nous accédons à ces variables via l'adresse ou le pointeur.

Dans SMA, le programmeur sait de la période antérieure que le nombre de variables ou le nombre de souvenirs requis pour son programme.

Mais dans DMA, le programmeur ne sait pas de l'état antérieur que le nombre de variables ou de mémoire requis, cela dépend de l'exigence de l'utilisateur.

Types de DMA:

1. malloc ()
2. calloc ()
3. realloc ()
4. Gratuit ()

malloc ()

La fonction malloc () est une instruction d'action lorsque le compilateur a lu cette ligne. Le compilateur ne comprend pas combien de souvenirs est alloué car il s'agit d'une déclaration d'action. Dans le bloc de mémoire d'exécution est créé.

Chaque fois que nous appelons Malloc (), nous passons un nombre comme argument, qu'il peut comprendre que le nombre d'octets de bloc de mémoire doit être créé par le malloc (). Dans malloc (), il ne peut déclarer aucun type de données. Malloc () renvoie toujours l'adresse, quel bloc de mémoire est créé.

Le type de retour malloc () est un pointeur vide car il ne sait pas quels types d'adresse qu'il renvoie. Pour cela, nous devons taper la caste.

P = (float *) malloc (4);

Ici, nous tapons la caste, car malloc () est un pointeur vide.

Exemple 1:

#inclure
#inclure
#define null 0
int main ()

int * a, * t;
Taille int;
printf ("Quelle est la taille de la table ? ");
scanf ("% d", & size);
printf ("\ n");
if ((t = (int *) malloc (taille * sizeof (int))) == null)

printf ("pas d'espace disponible \ n");
sortie (1);

printf ("\ n L'adresse du premier octet est% u \ n", t);
/ * Valeurs de table de lecture * /
printf ("\ n TABLE d'entrée Valeurs \ n");
pour (a = t; a < t + size ; a++ )
scanf ("% d", a);
/ * Valeurs de la table d'impression dans l'ordre inverse * /
pour (a = t + taille - 1; a> = t; a -)
printf ("% d est stocké à l'adresse% u \ n", * a, a);
libre (t);
retour 0;

Sortir:

Calloc ():

Avec l'aide de calloc (), nous pouvons créer plus d'un bloc ou un tableau dans Calloc (nous passons deux arguments; le 1er est le nombre de blocs que nous voulons créer et le 2e est la taille du bloc). calloc () renvoie également l'adresse dans chaque bloc par par défaut 0 existe.

Exemple-2:

#inclure
#inclure
int main ()

int * n, * freq, i, taille;
printf ("Quelle est la taille de la liste ? ");
scanf ("% d", & size);
n = (int *) malloc (taille * sizeof (int));
printf ("Entrez les numéros:");
pour (i = 0; i < size ; i++ )

printf ("\ n Entrez le num [% d]:", i);
scanf ("% d", & n [i]);
si (n [i] < 0 || n [ i ] > 4)

printf ("\ n Le nombre doit être dans la plage (0-4)");
je-- ;
continuer ;


freq = (int *) calloc (5, sizeof (int));
pour (i = 0; i < size ; i++ )
freq [n [i]] ++;
printf ("\ n Les fréquences des nombres sont:");
pour (i = 0; i < 5 ; i++ )
printf ("\ n freq [% d] =% d", i, freq [i]);
printf ("\ n");
gratuit (freq);
retour 0;

Sortir:

realloc ()

Chaque fois que nous créons un bloc à l'aide de malloc () ou de calloc () et que nous voulons modifier ou redimensionner le bloc, nous utilisons Realloc ().

Void * realloc (Void * Block, Taille int)

Dans realloc (), nous devons passer l'adresse comme un argument à partir duquel nous voulons redimensionner.

realloc (ptr, 8);

et la taille du bloc que nous voulons redimensionner. Cette taille, nous devons passer un argument dans Realloc ().

Double * Q;
q = realloc (ptr, 8);

Seuls les blocs créés par malloc () ou calloc () peuvent être redimensionnés par realloc ().

Exemple-3:

#inclure
#inclure
#inclure
#define null 0
int main()

tampon char *;
/ * Allouant la mémoire * /
if ((tampon = (char *) malloc (10)) == null)

printf ("Malloc a échoué. \ n ");
sortie (1);

printf ("tampon de taille% d créé \ n", sizeof (tampon));
strcpy (tampon, "Hyderabad");
printf ("\ n buffer contient:% s \ n", tampon);
/ * Reallocation * /
if ((tampon = (char *) realloc (tampon, 15)) == null)
printf ("Reallocation a échoué. \ n ");
sortie (1);

printf ("\ n Taille du tampon modifié. \ n ");
printf ("\ n tampon contient toujours:% s \ n", tampon);
strcpy (tampon, "secunderabad");
printf ("\ n tampon contient désormais:% s \ n", tampon);
/ * Libérer la mémoire * /
gratuit (tampon);
retour 0;

Sortir:

gratuit ()

Avec l'aide de libre (), nous libérons le bloc de mémoire créé par malloc () ou calloc () ou realloc ().

Les variables statiques n'existent que dans la portée du bloc ou une fonction. Si nous ne pouvons pas exécuter le libre (), chaque fois que la variable statique P est détruite, la variable qui est créée dynamiquement, qui ne sont pas détruites, mais restent pour toujours en RAM ou en mémoire. C'est ce qu'on appelle la fuite de mémoire. Pour ce libre () est nécessaire pour détruire le bloc de mémoire créé dynamiquement.

Libre () ne détruise que la mémoire créée dynamiquement.

Conclusion:

DMA est un concept puissant en C en C car il supprime l'inconvénient de SMA. Dans SMA, nous devons prendre une décision avant d'exécuter le programme dont le nombre de blocs de mémoire est créé. En conséquence, la mémoire est gaspillée ou la mémoire ne suffit pas. DMA résoudre le problème en prenant une décision sur le temps d'exécution dont le nombre de blocs est nécessaire pour allouer la mémoire. Il attribue la mémoire à l'exigence du programme.