Allocation dynamique de mémoire en C

Dans ce tutoriel, vous apprendrez à utiliser les fonctions de bibliothèque standard : malloc(), calloc(), free() et realloc() pour allouer de la mémoire dynamiquement dans un programme C.

Comme vous le savez, un tableau est un ensemble de valeurs fixes. Une fois la taille du tableau déclarée, vous ne pouvez pas la changer.

Parfois, la taille de l'array que vous déclarez peut ne pas être suffisante. Pour résoudre ce problème, vous pouvez allouer manuellement de la mémoire au cours de l'exécution. Cela s'appelle l'allocation de mémoire dynamique en programmation C.

Il est possible d'utiliser les fonctions de bibliothèque standard malloc(), calloc(), realloc() et free() pour allouer de la mémoire dynamiquement. Ces fonctions sont définies dans le fichier d'en-tête <stdlib.h>.

C malloc()

Le nom "malloc" signifie allocation de mémoire.

La fonction malloc() conserve un bloc de mémoire de la taille spécifiée. Et elle retourne un voidpointeurpeut être convertie en tout type de pointeur.

La syntaxe de malloc()

ptr = (castType*) malloc(size);

Exemple

ptr = (float*) malloc(100　*　sizeof(float));

La ligne ci-dessus alloue400 octets de mémoire. Parce que la taille des nombres en virgule flottante est4octets. De plus, le pointeur ptr conserve l'adresse du premier octet de la mémoire allouée.

Si l'allocation de mémoire échoue, l'expression produira un pointeur NULL.

C calloc()

Le nom "calloc" signifie allocation continue.

La fonction malloc() alloue de la mémoire et conserve la mémoire non initialisée. La fonction calloc() alloue de la mémoire et initialise tous les bits à zéro.

Syntaxe de calloc()

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

Exemple :

ptr = (float*)calloc(25, sizeof(float));

L'instruction ci-dessus alloue de l'espace en mémoire pour25éléments de type float分配连续空间。

C free()

La mémoire allouée dynamiquement avec calloc() ou malloc() ne se libère pas automatiquement. Il est nécessaire d'utiliser explicitement free() pour libérer l'espace.

Syntaxe de free()

free(ptr);

Cette instruction libère l'espace alloué dans la mémoire pointée par ptr.

Exemple1：malloc() et free()

//Programme pour calculer la somme des n nombres saisis par l'utilisateur
#include <stdio.h>
#include <stdlib.h>
int main()
{
　　　　int n, i,　*ptr, sum = 0;
　　　　printf("Entrer le nombre d'éléments: ");
　　　　scanf("%d", &n);
　　　　ptr = (int*)malloc(n　*　sizeof(int));
　
　　　　//　Si la mémoire ne peut pas être allouée
　　　　if(ptr == NULL)　　　　　　　　　　　　　　　　　　　　　
　　　　{
　　　　　　　　printf("Erreur ! Mémoire non allouée.");
　　　　　　　　exit(0);
　　　　}
　　　　printf("Entrer l'élément: ");
　　　　for(i = 0; i < n;　++i)
　　　　{
　　　　　　　　scanf("%d", ptr　+　i);
　　　　　　　　sum　+=　*(ptr　+　i);
　　　　}
　　　　printf("Sum = %d", sum);
　　
　　　　//Libérer la mémoire
　　　　free(ptr);
　　　　return 0;
}

Ici, nous avons alloué dynamiquement de la mémoire pour n int.

Exemple2：calloc() et free()

//Programme pour calculer la somme des n nombres saisis par l'utilisateur
#include <stdio.h>
#include <stdlib.h>
int main()
{
　　　　int n, i,　*ptr, sum = 0;
　　　　printf("Entrer le nombre d'éléments: ");
　　　　scanf("%d", &n);
　　　　ptr = (int*)calloc(n, sizeof(int));
　　　　if(ptr == NULL)
　　　　{
　　　　　　　　printf("Erreur ! Mémoire non allouée.");
　　　　　　　　exit(0);
　　　　}
　　　　printf("Entrer l'élément: ");
　　　　for(i = 0; i < n;　++i)
　　　　{
　　　　　　　　scanf("%d", ptr　+　i);
　　　　　　　　sum　+=　*(ptr　+　i);
　　　　}
　　　　printf("Sum = %d", sum);
　　　　free(ptr);
　　　　return 0;
}

C realloc()

Si la mémoire allouée dynamiquement est insuffisante ou excède la taille nécessaire, vous pouvez utiliser la fonction realloc() pour modifier la taille de la mémoire allouée précédemment.

Syntaxe de realloc()

ptr = realloc(ptr, x);

Ici, ptr est réalloué à la nouvelle taille x.

Exemple3：realloc()

#include <stdio.h>
#include <stdlib.h>
int main()
{
　　　　int　*ptr, i, n1, n2;
　　　　printf("Entrer la taille: ");
　　　　scanf("%d", &n1);
　　　　ptr = (int*)malloc(n1　*　sizeof(int));
　　　　printf("Adresse de mémoire allouée précédente: ");
　　　　for (i = 0; i < n1;　++i)
　　　　　　　　printf("睵n", ptr　+　i);
　　　　printf("\nEntrer la nouvelle taille: ");
　　　　scanf("%d", &n2);
　　　　//Réallouer la mémoire
　　　　ptr = realloc(ptr, n2　*　sizeof(int));
　　　　printf("Nouvelle adresse de mémoire allouée: ");
　　　　for (i = 0; i < n2;　++i)
　　　　　　　　printf("睵n", ptr　+　i);
　　　　free(ptr);
　　　　return 0;
}

Lorsque le programme est exécuté, la sortie est :

Entrez la taille:　3
Adresse de la mémoire allouée précédemment:　7452312
7452316
7452320
Entrez la nouvelle taille:　5
Adresse de la mémoire allouée récemment:　7452312
7452316
7452320
7452324
7452328