Gestion de la mémoire en C

Bonjour à tous, futurs magiciens de la programmation ! Aujourd'hui, nous plongeons dans le monde fascinant de la gestion de la mémoire en C. Ne vous inquiétez pas si vous êtes nouveau dans la programmation ; je vais vous guider à travers ce voyage pas à pas, tout comme j'ai fait pour des centaines d'étudiants au fil des ans. Alors, mettez vos casques virtuels, et explorons le chantier de la mémoire informatique !

C - Memory Management

Fonctions pour la gestion dynamique de la mémoire en C

Avant de commencer à construire nos gratte-ciel de mémoire, familiarisons-nous avec les outils que nous allons utiliser. En C, nous avons un ensemble de fonctions qui nous aident à gérer la mémoire dynamiquement. Pensez à ces fonctions comme à votre boîte à outils fiable :

Fonction	But
malloc()	Alloue un bloc de mémoire
calloc()	Alloue et initialise plusieurs blocs de mémoire
realloc()	Redimensionne un bloc de mémoire préalablement alloué
free()	Libère la mémoire allouée pour le système

Ces fonctions sont comme l'équipe de construction pour nos bâtiments de mémoire. Chacune a son propre travail spécial, et nous allons les connaître toutes intiment.

Allocation de mémoire dynamique

Imaginez que vous organisez une fête, mais vous ne savez pas combien d'invités vont venir. C'est là que l'allocation dynamique de mémoire devient pratique ! Au lieu de prévoir un nombre fixe de chaises, vous pouvez en ajouter ou en enlever selon les besoins. Voyons comment nous faisons cela en C.

La fonction malloc()

Notre premier super-héros de l'allocation de mémoire est malloc(). Il signifie "allocation de mémoire" et est utilisé pour demander un bloc de mémoire au système.

#include <stdio.h>
#include <stdlib.h>

int main() {
int *numbers;
int size = 5;

numbers = (int*)malloc(size * sizeof(int));

if (numbers == NULL) {
printf("Échec de l'allocation de mémoire !\n");
return 1;
}

for (int i = 0; i < size; i++) {
numbers[i] = i * 10;
printf("numbers[%d] = %d\n", i, numbers[i]);
}

free(numbers);
return 0;
}

Décomposons cela :

Nous incluons <stdlib.h> car c'est là que se trouve malloc().
Nous déclarons un pointeur numbers pour stocker notre tableau alloué dynamiquement.
malloc(size * sizeof(int)) demande assez de mémoire pour contenir 5 entiers.
Nous castons le résultat en (int*) car malloc() renvoie un pointeur void.
Vérifiez toujours si malloc() a réussi ! Si elle renvoie NULL, c'est que nous sommes dans la merde (et sans mémoire).
Nous pouvons maintenant utiliser numbers comme un tableau régulier.
N'oubliez pas de free() la mémoire lorsque vous avez fini !

La fonction calloc()

Maintenant, découvrez calloc(), le maniaque de la propreté de l'allocation de mémoire. Alors que malloc() vous donne de la mémoire avec ce qui était là avant, calloc() nettoie après lui-même, initialisant toute la mémoire allouée à zéro.

#include <stdio.h>
#include <stdlib.h>

int main() {
int *numbers;
int size = 5;

numbers = (int*)calloc(size, sizeof(int));

if (numbers == NULL) {
printf("Échec de l'allocation de mémoire !\n");
return 1;
}

for (int i = 0; i < size; i++) {
printf("numbers[%d] = %d\n", i, numbers[i]);
}

free(numbers);
return 0;
}

Les différences clés ici :

calloc() prend deux arguments : le nombre d'éléments et la taille de chaque élément.
Tous les éléments sont initialisés à zéro, donc notre sortie sera entièrement en zéros.

Redimensionnement et libération de la mémoire

Parfois, notre fête devient plus grande ou plus petite que prévu. C'est là que realloc() devient pratique !

La fonction realloc()

realloc() est comme un magicien qui peut agrandir ou réduire notre bloc de mémoire.

#include <stdio.h>
#include <stdlib.h>

int main() {
int *numbers;
int size = 5;

numbers = (int*)malloc(size * sizeof(int));

if (numbers == NULL) {
printf("Échec de l'allocation de mémoire !\n");
return 1;
}

for (int i = 0; i < size; i++) {
numbers[i] = i * 10;
printf("numbers[%d] = %d\n", i, numbers[i]);
}

// Agrandissons notre tableau
size = 10;
numbers = (int*)realloc(numbers, size * sizeof(int));

if (numbers == NULL) {
printf("Échec du redimensionnement de la mémoire !\n");
return 1;
}

// Remplissons les nouveaux éléments
for (int i = 5; i < size; i++) {
numbers[i] = i * 10;
}

// Affichons tous les éléments
for (int i = 0; i < size; i++) {
printf("numbers[%d] = %d\n", i, numbers[i]);
}

free(numbers);
return 0;
}

Voici ce qui se passe :

Nous commencerons avec 5 éléments, comme avant.
Nous utilisons realloc() pour agrandir notre tableau à 10 éléments.
realloc() garde notre données d'origine intactes et nous donne plus d'espace.
Nous remplissons les nouveaux éléments et affichons tout.

La fonction free()

Enfin, nous avons free(), l'équipe de nettoyage de notre gestion de la mémoire. Souvenez-vous toujours de free() votre mémoire allouée lorsque vous avez fini avec elle !

#include <stdio.h>
#include <stdlib.h>

int main() {
int *numbers = (int*)malloc(5 * sizeof(int));

if (numbers == NULL) {
printf("Échec de l'allocation de mémoire !\n");
return 1;
}

for (int i = 0; i < 5; i++) {
numbers[i] = i * 10;
printf("numbers[%d] = %d\n", i, numbers[i]);
}

free(numbers);  // Nettoyage !
numbers = NULL; // Bonne pratique pour éviter d'utiliser de la mémoire libérée

// Essayer d'utiliser 'numbers' maintenant serait une mauvaise idée !

return 0;
}

Souvenez-vous :

Toujours free() la mémoire que vous avez allouée lorsque vous en avez fini.
Mettez le pointeur à NULL après l'avoir libéré pour éviter une utilisation accidentelle de la mémoire libérée.
Ne jamais essayer de free() de la mémoire que vous n'avez pas allouée dynamiquement.

Et voilà, amis ! Nous avons construit nos gratte-ciel de gestion de la mémoire, appris à allouer de l'espace pour nos invités de fête, à réorganiser les lieux si nécessaire, et à nettoyer après coup. Souvenez-vous, une bonne gestion de la mémoire est comme être un bon hôte - assurez-vous d'avoir assez de place pour vos invités, soyez flexible dans vos arrangements, et nettoyez soigneusement lorsque la fête est terminée !

Continuez à pratiquer ces concepts, et bientôt vous serez l'architecte maître de la mémoire de votre programme. Bonne programmation, et que vos programmes fonctionnent toujours sans fuite de mémoire !

Credits: Image by storyset

Tutoriel précédent:

C - Fichiers d'en-tête

Tutoriel suivant:

C - Adresse mémoire