Allocation dynamique de mémoire en C : fonctions malloc(), calloc()

#include <stdio.h>int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}

 The size of float is 4 bytes 

#include <stdio.h>int main() { float arr;printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;} 

 The size of the float array with 10 element is 40

Comme appris jusqu’ici, lors de la déclaration d’un type de données de base ou d’un tableau, la mémoire est automatiquement gérée. Cependant, il existe un processus d’allocation de mémoire en C qui vous permettra de mettre en œuvre un programme dans lequel la taille du tableau est indécise jusqu’à l’exécution de votre programme (runtime). Ce processus est appelé « allocation dynamique de mémoire ».

Dans ce tutoriel, vous allez apprendre-

• Comment fonctionne la gestion de la mémoire en C ?
• Allocation dynamique de mémoire en C
• La fonction malloc() en C
• La fonction free()
• La fonction calloc() en C
• Calloc() vs. malloc() : Principales différences
• Fonction C realloc()
• Réseaux dynamiques

Maintenant, vous pouvez créer et détruire un tableau d’éléments de manière dynamique au moment de l’exécution sans aucun problème. Pour résumer, la gestion automatique de la mémoire utilise la pile, et l’allocation dynamique de mémoire en C utilise le tas.

La bibliothèque <stdlib.h> possède des fonctions responsables de la gestion dynamique de la mémoire.

Fonction	Objectif
malloc()	Allocation de la mémoire de taille demandée et renvoi du pointeur vers le premier octet de l’espace alloué.
Calloc()	Allocation de l’espace pour les éléments d’un tableau. Initialise les éléments à zéro et renvoie un pointeur vers la mémoire.
Ralloc()	Il est utilisé pour modifier la taille de l’espace mémoire précédemment alloué.
Free()	Elle libère ou vide l’espace mémoire précédemment alloué.

Discutons des fonctions ci-dessus avec leur application

Syntaxe de la fonction malloc() :

ptr = (cast_type *) malloc (byte_size);

Ici,

• ptr est un pointeur de type cast_type.
• La fonction C malloc() renvoie un pointeur vers la mémoire allouée de taille byte_size.

Exemple de malloc() :

Example: ptr = (int *) malloc (50)

Lorsque cette instruction est exécutée avec succès, un espace mémoire de 50 octets est réservé. L’adresse du premier octet de l’espace réservé est affectée au pointeur ptr de type int.

Considérez un autre exemple :

#include <stdlib.h>int main(){int *ptr;ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */ if (ptr != NULL) { *(ptr + 5) = 480; /* assign 480 to sixth integer */ printf("Value of the 6th integer is %d",*(ptr + 5)); }}

Sortie :

Value of the 6th integer is 480

1. Notez que sizeof(*ptr) a été utilisé au lieu de sizeof(int) afin de rendre le code plus robuste lorsque la déclaration *ptr est typée vers un type de données différent plus tard.
2. L’allocation peut échouer si la mémoire n’est pas suffisante. Dans ce cas, elle renvoie un pointeur NULL. Vous devez donc inclure du code pour vérifier la présence d’un pointeur NULL.
3. N’oubliez pas que la mémoire allouée est contiguë et qu’elle peut être traitée comme un tableau. Nous pouvons utiliser l’arithmétique des pointeurs pour accéder aux éléments du tableau plutôt que d’utiliser des parenthèses . Nous conseillons d’utiliser + pour se référer aux éléments du tableau car l’utilisation de l’incrémentation ++ ou += change l’adresse stockée par le pointeur.

La fonction Malloc() peut également être utilisée avec le type de données de caractères ainsi que les types de données complexes tels que les structures.

Par exemple :

#include <stdio.h>int main() {int* ptr = malloc(10 * sizeof(*ptr));if (ptr != NULL){ *(ptr + 2) = 50; printf("Value of the 2nd integer is %d",*(ptr + 2));}free(ptr);}

Sortie

 Value of the 2nd integer is 50

Syntaxe de la fonction calloc() :

ptr = (cast_type *) calloc (n, size);

• L’instruction ci-dessus est utilisée pour allouer n blocs de mémoire de même taille.
• Après l’allocation de l’espace mémoire, alors tous les octets sont initialisés à zéro.
• Le pointeur qui est actuellement au premier octet de l’espace mémoire alloué est retourné.

Lorsqu’il y a une erreur d’allocation de l’espace mémoire comme le manque de mémoire, alors un pointeur nul est renvoyé.

Exemple de calloc() :

Le programme ci-dessous calcule la somme d’une suite arithmétique.

#include <stdio.h> int main() { int i, * ptr, sum = 0; ptr = calloc(10, sizeof(int)); if (ptr == NULL) { printf("Error! memory not allocated."); exit(0); } printf("Building and calculating the sequence sum of the first 10 terms \ n "); for (i = 0; i < 10; ++i) { * (ptr + i) = i; sum += * (ptr + i); } printf("Sum = %d", sum); free(ptr); return 0; }

Résultat :

 Building and calculating the sequence sum of the first 10 termsSum = 45

calloc() vs. malloc() : Principales différences

Voici les principales différences entre malloc() Vs calloc() en C :

La fonction calloc() est généralement plus adaptée et efficace que celle de la fonction malloc(). Alors que les deux fonctions sont utilisées pour allouer de l’espace mémoire, calloc() peut allouer plusieurs blocs en une seule fois. Vous n’avez pas besoin de demander un bloc de mémoire à chaque fois. La fonction calloc() est utilisée dans les structures de données complexes qui nécessitent un espace mémoire plus important.

Le bloc de mémoire alloué par un calloc() en C est toujours initialisé à zéro alors que dans la fonction malloc() en C, il contient toujours une valeur poubelle.

Syntaxe de la fonction realloc() :

ptr = realloc (ptr,newsize);

L’instruction ci-dessus alloue un nouvel espace mémoire avec une taille spécifiée dans la variable newsize. Après l’exécution de la fonction, le pointeur sera renvoyé au premier octet du bloc mémoire. La nouvelle taille peut être plus grande ou plus petite que la mémoire précédente. Nous ne pouvons pas être sûrs que le bloc nouvellement alloué pointera vers le même emplacement que celui du bloc de mémoire précédent. Cette fonction copiera toutes les données précédentes dans la nouvelle région. Elle permet de s’assurer que les données resteront en sécurité.

Exemple de realloc() :

#include <stdio.h>int main () { char *ptr; ptr = (char *) malloc(10); strcpy(ptr, "Programming"); printf(" %s, Address = %u\n", ptr, ptr); ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new size strcat(ptr, " In 'C'"); printf(" %s, Address = %u\n", ptr, ptr); free(ptr); return 0;} 

Lorsque la fonction realloc() en C aboutit à une opération infructueuse, elle renvoie un pointeur nul, et les données précédentes sont également libérées.

#include <stdio.h> int main() { int * arr_dynamic = NULL; int elements = 2, i; arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocks for (i = 0; i < elements; i++) arr_dynamic = i; for (i = 0; i < elements; i++) printf("arr_dynamic=%d\n", i, arr_dynamic); elements = 4; arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); //reallocate 4 elements printf("After realloc\n"); for (i = 2; i < elements; i++) arr_dynamic = i; for (i = 0; i < elements; i++) printf("arr_dynamic=%d\n", i, arr_dynamic); free(arr_dynamic); } 

Résultat du programme de tableau dynamique en C à l’écran :

 arr_dynamic=0arr_dynamic=1After reallocarr_dynamic=0arr_dynamic=1arr_dynamic=2arr_dynamic=3

Sommaire

• Nous pouvons gérer dynamiquement la mémoire en créant des blocs de mémoire selon les besoins dans le tas
• Dans l’allocation dynamique de mémoire en C, la mémoire est allouée lors d’une exécution.
• L’allocation dynamique de mémoire permet de manipuler des chaînes et des tableaux dont la taille est flexible et peut être modifiée à tout moment dans votre programme.
• Elle est nécessaire lorsque vous n’avez aucune idée de la quantité de mémoire qu’une structure particulière va occuper.
• Malloc() en C est une fonction d’allocation de mémoire dynamique qui représente l’allocation de mémoire que des blocs de mémoire avec la taille spécifique initialisée à une valeur de poubelle
• Calloc() en C est une fonction d’allocation de mémoire contiguë qui alloue plusieurs blocs de mémoire à la fois initialisée à 0
• Realloc() en C est utilisé pour réallouer la mémoire selon la taille spécifiée.
• La fonctionFree() est utilisée pour effacer la mémoire allouée dynamiquement.

.