Allocation dynamique de mémoire en C à l'aide des fonctions malloc(), calloc()

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é la pile .

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

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

Le résultat sera :

 The size of float is 4 bytes

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

#include <stdio.h>
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éterminée jusqu'à ce que vous exécutiez votre programme (runtime). Ce processus est appelé "Allocation dynamique de mémoire ."

Dans ce tutoriel, vous apprendrez-

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

Allocation de mémoire dynamique en C

Allocation de mémoire dynamique est une allocation manuelle et une 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 dynamiquement un tableau d'éléments lors 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 Objectif 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.realloc() Il est utilisé pour modifier la taille de l'espace mémoire précédemment alloué.Free() Libère ou vide l'espace mémoire précédemment alloué.

Discutons des fonctions ci-dessus avec leur application

fonction malloc() en C

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 un espace mémoire de 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 <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

Remarquez que sizeof(*ptr) a été utilisé à la place de sizeof(int) afin de rendre le code plus robuste lorsque la déclaration *ptr est convertie ultérieurement en un type de données différent.
L'allocation peut échouer si la mémoire n'est pas suffisante. Dans ce cas, il retourne un pointeur NULL. Donc, vous devez inclure le code pour vérifier un pointeur NULL.
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 +=modifie 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 les types de données complexes tels que les structures.

fonction free() en C

La mémoire pour les variables est automatiquement désallouée au moment de la compilation. Dans l'allocation de mémoire dynamique, vous devez libérer explicitement la mémoire. Si ce n'est pas fait, vous pouvez rencontrer une erreur de mémoire insuffisante.

Le libre() La fonction est appelée pour libérer/libérer 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 <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

fonction calloc() en C

La fonction C calloc() représente l'allocation contiguë. Cette fonction est utilisée pour allouer plusieurs blocs de mémoire. Il s'agit d'une fonction d'allocation de mémoire dynamique utilisée pour allouer de 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 calloc() en C est utilisée 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 qu'un manque de mémoire, 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 terms
Sum = 45

calloc() vs malloc() :principales différences

Voici la principale différence entre malloc() et 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 à la 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 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.

fonction realloc() en C

Utilisation du C realloc() fonction, vous pouvez ajouter plus de taille de mémoire à la mémoire déjà allouée. Il développe le bloc actuel tout en laissant le contenu d'origine tel quel. realloc() en C signifie réallocation de 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 l'exécution de la fonction, le pointeur sera renvoyé au premier octet du bloc de 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. Il garantit 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;
}

Chaque fois que 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 <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] = 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 elements
        printf("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]=0
arr_dynamic[1]=1
After realloc
arr_dynamic[0]=0
arr_dynamic[1]=1
arr_dynamic[2]=2
arr_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 de mémoire dynamique 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 représente l'allocation de mémoire qui bloque la mémoire avec la taille spécifique initialisée à une valeur poubelle
Calloc() en C est une fonction d'allocation de mémoire contiguë qui alloue plusieurs blocs de mémoire à la fois initialisés à 0
Realloc() en C est utilisé pour réallouer 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.

Opérateurs au niveau du bit en C :AND, OR, XOR, Shift &Complement Conversion de type en C :conversion de type, implicite, explicite avec exemple

Langue C