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

Table des matières:

Anonim

Avant d'apprendre l'allocation de mémoire dynamique C, comprenons:

Comment fonctionne la gestion de la mémoire en C?

Lorsque vous déclarez une variable à l'aide d'un type de données de base, le compilateur C alloue automatiquement de l'espace mémoire pour la variable dans un pool de mémoire appelé pile .

Par exemple, une variable float prend généralement 4 octets (selon la plateforme) lorsqu'elle est déclarée. Nous pouvons vérifier ces informations en utilisant l' opérateur sizeof comme indiqué dans l'exemple ci-dessous

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

La sortie sera:

 The size of float is 4 bytes

De plus, un tableau avec une taille spécifiée est alloué dans des blocs contigus de mémoire, chaque bloc a la taille d'un élément:

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

Le résultat est:

 The size of the float array with 10 element is 40

Comme appris jusqu'à présent, 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 d'implémenter un programme dans lequel la taille du tableau est indécise jusqu'à ce que vous exécutiez votre programme (runtime). Ce processus est appelé « allocation de mémoire dynamique ».

Dans ce didacticiel, vous apprendrez-

  • Comment fonctionne la gestion de la mémoire en C?
  • Allocation de mémoire dynamique en C
  • Fonction C malloc ()
  • La fonction free ()
  • Fonction C calloc ()
  • calloc () vs malloc (): différences clés
  • Fonction C realloc ()
  • Tableaux dynamiques

Allocation de mémoire dynamique en C

L'allocation dynamique de mémoire est l'allocation manuelle et la libération de mémoire en fonction de vos besoins de programmation. La mémoire dynamique est gérée et servie avec des pointeurs qui pointent vers l'espace mémoire nouvellement alloué dans une zone que nous appelons le tas.

Vous pouvez désormais 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 de mémoire dynamique C utilise le tas.

La bibliothèque a des fonctions responsables de la gestion dynamique de la mémoire.

Fonction But
malloc () Alloue la mémoire de la taille demandée et renvoie le pointeur sur le premier octet de l'espace alloué.
calloc () Alloue l'espace pour les éléments d'un tableau. Initialise les éléments à zéro et renvoie un pointeur vers la mémoire.
réallouer () Il est utilisé pour modifier la taille de l'espace mémoire précédemment alloué.
Libérer() Libère ou vide l'espace mémoire précédemment alloué.

Discutons des fonctions ci-dessus avec leur application

Fonction C malloc ()

La fonction C malloc () représente l'allocation de mémoire. C'est une fonction qui permet d'allouer dynamiquement un bloc de mémoire. Il réserve l'espace mémoire de la taille spécifiée et renvoie le pointeur nul pointant vers l'emplacement mémoire. Le pointeur renvoyé est généralement de type void. Cela signifie que nous pouvons assigner la fonction C malloc () à n'importe quel pointeur.

Syntaxe de la fonction malloc ():

ptr = (cast_type *) malloc (byte_size);

Ici,

  • ptr est un pointeur de cast_type.
  • La fonction C malloc () renvoie un pointeur vers la mémoire allouée de 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.

Prenons un autre exemple:

#include 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));}}

Production:

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 ultérieurement vers un type de données différent.
  2. L'allocation peut échouer si la mémoire n'est pas suffisante. Dans ce cas, il renvoie un pointeur NULL. Vous devez donc inclure du code pour rechercher un pointeur NULL.
  3. Gardez à l'esprit 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 crochets []. Nous conseillons d'utiliser + pour faire référence 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 caractère ainsi que des types de données complexes tels que les structures.

La fonction free ()

La mémoire des variables est automatiquement désallouée au moment de la compilation. Dans l'allocation de mémoire dynamique, vous devez désallouer explicitement la mémoire. Sinon, vous risquez de rencontrer une erreur de mémoire insuffisante.

La fonction free () est appelée pour libérer / désallouer de la mémoire en C. En libérant de la mémoire dans votre programme, vous en rendez plus disponible pour une utilisation ultérieure.

Par exemple:

#include 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);}

Production

 Value of the 2nd integer is 50

Fonction C calloc ()

La fonction C calloc () signifie allocation contiguë. Cette fonction permet d'allouer plusieurs blocs de mémoire. Il s'agit d'une fonction d'allocation de mémoire dynamique qui est utilisée pour allouer la mémoire à des structures de données complexes telles que des tableaux et des structures.

La fonction Malloc () est utilisée pour allouer un seul bloc d'espace mémoire tandis que le calloc () en C est utilisé pour allouer plusieurs blocs d'espace mémoire. Chaque bloc alloué par la fonction calloc () est de la même taille.

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.
  • Une fois l'espace mémoire alloué, tous les octets sont initialisés à zéro.
  • Le pointeur qui se trouve actuellement sur le premier octet de l'espace mémoire alloué est renvoyé.

Chaque fois qu'il y a une erreur d'allocation d'espace mémoire telle que le manque de mémoire, un pointeur nul est renvoyé.

Exemple de calloc ():

Le programme ci-dessous calcule la somme d'une séquence arithmétique.

#include 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 (): différences clés

Voici la principale différence entre malloc () et calloc () en C:

La fonction calloc () est généralement plus approprié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 à la fois. Vous n'êtes pas obligé de demander un bloc de mémoire à chaque fois. La fonction calloc () est utilisée dans des structures de données complexes qui nécessitent un plus grand espace mémoire.

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

Fonction C realloc ()

En utilisant la fonction C realloc () , vous pouvez ajouter plus de taille de mémoire à la mémoire déjà allouée. Il étend le bloc actuel tout en laissant le contenu original tel quel. realloc () en C signifie réallocation de la mémoire.

realloc () peut également être utilisé pour réduire la taille de la mémoire précédemment allouée.

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 avoir exécuté la fonction, le pointeur sera renvoyé sur le 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 si le bloc nouvellement alloué pointera vers le même emplacement que celui du bloc mémoire précédent. Cette fonction copiera toutes les données précédentes dans la nouvelle région. Cela garantit que les données resteront en sécurité.

Exemple de realloc ():

#include 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 sizestrcat(ptr, " In 'C'");printf(" %s, Address = %u\n", ptr, ptr);free(ptr);return 0;}

Chaque fois que le realloc () en C aboutit à une opération infructueuse, il renvoie un pointeur nul et les données précédentes sont également libérées.

Tableaux dynamiques en C

Un tableau dynamique en C permet au nombre d'éléments d'augmenter selon les besoins. C Les tableaux dynamiques sont largement utilisés dans les algorithmes informatiques.

Dans le programme suivant, nous avons créé et redimensionné un tableau dynamique en C

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

Résultat du programme C Dynamic array à l'écran:

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

Résumé

  • 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 de mémoire dynamique C, la mémoire est allouée au moment de l'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.
  • Il 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 correspond à l'allocation de mémoire qui bloque la mémoire avec la taille spécifique initialisée à une valeur de garbage
  • Calloc () en C est une fonction d'allocation de mémoire contiguë qui alloue plusieurs blocs de mémoire à la fois initialisé à 0
  • Realloc () en C est utilisé pour réallouer de la mémoire en fonction de la taille spécifiée.
  • La fonction Free () est utilisée pour effacer la mémoire allouée dynamiquement.