Allocation dynamique de la mémoire et pointeurs en C

int a = 10;  // Déclaration et initialisation d'une variable entière
int *p;// Déclaration d'un pointeur vers un entier
p = &a;// Initialisation du pointeur avec l'adresse de la variable 'a'
*p = 2;// Utilisation du pointeur pour modifier la valeur de 'a'

• Pour pouvoir affecter directement une valeur à *p, il est nécessaire de réserver un espace mémoire adéquat pour stocker la valeur. Cela se fait à l’aide de fonctions d’allocation dynamique de mémoire telles que malloc ou calloc.

int *p = (int*)malloc(sizeof(int));  // Allocation dynamique de mémoire pour un entier
if (p == NULL) {
    // Gestion de l'erreur si l'allocation échoue
    printf("Échec de l'allocation mémoire.\n");
    return 1;
}
*p = 2;  // Affectation de la valeur 2 à l'espace mémoire pointé par 'p'

nom_pointeur = (type_pointeur) malloc(nombre_octets);
nom_pointeur : Le nom du pointeur qui recevra l'adresse du bloc de mémoire alloué.
type_pointeur : Le type de données du pointeur. La conversion de type (cast) est nécessaire pour correspondre au type du pointeur.
nombre_octets : Le nombre d'octets à allouer. La fonction sizeof(type_objet) est souvent utilisée pour déterminer ce nombre.

#include <stdlib.h>

int main() {
    int *p;// Déclaration d'un pointeur vers un entier
    p = (int *)malloc(sizeof(int)); // Allocation dynamique de mémoire pour un entier
    if (p == NULL) {
        // Vérification de la réussite de l'allocation
        return 1;
    }
    *p = 10;// Affectation de la valeur 10 à l'espace mémoire alloué
    free(p);// Libération de la mémoire allouée
    return 0;
}

#include 
#include 
#include 

int main() {
    int i = 3;                      // Déclaration et initialisation d'un entier
    int *p = NULL;                  // Initialisation d'un pointeur à NULL

    // Affichage de la valeur de p avant l'initialisation
    printf("Valeur de p avant initialisation = %p\n", (void *)p);

    p = (int *)malloc(sizeof(int)); // Allocation dynamique de mémoire pour un entier

    // Affichage de la valeur de p après l'initialisation
    printf("Valeur de p après initialisation = %p\n", (void *)p);
    
    if (p == NULL) {
        // Vérification de la réussite de l'allocation
        printf("Échec de l'allocation mémoire.\n");
        return 1;
    }

    *p = i;                         // Affectation de la valeur de i à l'espace mémoire alloué
    printf("Valeur de *p = %d\n", *p); // Affichage de la valeur de l'entier pointé par p

    free(p);                        // Libération de la mémoire allouée
    getch();                        // Attente d'une entrée de l'utilisateur
    return 0;
}

• Avant l’appel à malloc, p est initialisé à NULL, ce qui est une bonne pratique pour éviter les pointeurs indéfinis. L’affichage de NULL montre que p ne pointe vers aucune adresse valide avant l’allocation.

• Après l’appel à malloc, p contient l’adresse du bloc de mémoire alloué. Cette adresse est une valeur non nulle (par exemple 0x11424), ce qui signifie que l’allocation a réussi.

• Après l’affectation *p = i, la valeur pointée par p est 3, comme attendu, puisque i est initialisé à 3.

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

Libération de la Mémoire
Toute mémoire allouée dynamiquement avec malloc doit être libérée une fois qu’elle n’est plus nécessaire, en utilisant la fonction free :

free(p);

1. Exemple : Allocation Dynamique d’un Tableau

• Voici un exemple détaillé montrant comment allouer dynamiquement un tableau d’entiers en C.

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

int main() {
    int *p = NULL;  // Déclaration et initialisation du pointeur à NULL
    int i, n;

    printf("\nDonner le nombre d’éléments du tableau: ");
    scanf("%d", &n);  // Lecture du nombre d'éléments

    // Allocation dynamique de mémoire pour n entiers
    p = (int *)malloc(n * sizeof(int));
    if (p == NULL) {
        // Vérification de la réussite de l'allocation
        printf("Échec de l'allocation mémoire.\n");
        return 1;
    }

    // Initialisation des éléments du tableau à 0
    for (i = 0; i < n; i++) {
        *(p + i) = 0;  // Équivalent à p[i] = 0
    }

    // Affichage des éléments du tableau
    printf("Éléments du tableau après initialisation: ");
    for (i = 0; i < n; i++) {
        printf("%d ", p[i]);
    }
    printf("\n");

    free(p);  // Libération de la mémoire allouée

    return 0;
}

2. Explications des Concepts

1. Déclaration et Initialisation :

• int *p = NULL; : Le pointeur p est initialisé à NULL. Cela permet d'éviter des comportements indéfinis en cas de tentative d'utilisation avant allocation.

2. Lecture de la Taille du Tableau :

• scanf("%d", &n); : La fonction scanf lit la taille du tableau (le nombre d'éléments) entrée par l'utilisateur et la stocke dans n.

3. Allocation Dynamique de Mémoire :

• p = (int *)malloc(n * sizeof(int)); : La fonction malloc alloue n blocs de mémoire, chaque bloc ayant la taille d'un entier (sizeof(int)). La conversion de type (int *) est nécessaire pour que malloc retourne un pointeur de type int *.

4. Vérification de l'Allocation :

• if (p == NULL) { ... } : Il est important de vérifier que malloc n'a pas renvoyé NULL, ce qui indiquerait un échec de l'allocation de mémoire.

5. Initialisation des Éléments du Tableau :

• for (i = 0; i < n; i++) { *(p + i) = 0; } : Cette boucle initialise chaque élément du tableau à 0. L'expression *(p + i) est équivalente à p[i].

6. Affichage des Éléments du Tableau :

• for (i = 0; i < n; i++) { printf("%d ", p[i]); } : Cette boucle affiche les éléments du tableau après l'initialisation.

7. Libération de la Mémoire :

• free(p); : La mémoire allouée dynamiquement doit être libérée avec free pour éviter les fuites de mémoire.

3. Résumé

• L'exemple montre comment allouer dynamiquement un tableau d'entiers dont la taille est spécifiée par l'utilisateur à l'exécution.
• Chaque élément du tableau est ensuite initialisé à 0. Voici les étapes principales :
• Lecture de la taille du tableau.
• Allocation dynamique de mémoire pour le tableau.
• Initialisation des éléments du tableau.
• Affichage des éléments du tableau.
• Libération de la mémoire allouée.
• L'utilisation de l'allocation dynamique de mémoire permet de créer des structures de données flexibles qui peuvent s'adapter aux besoins de l'application à l'exécution.

1. Exemples

• Voici deux exemples pour illustrer comment allouer dynamiquement des structures et des tableaux de structures.

1. Exemple :01

• Allocation Dynamique d'une Seule Structure
• Ce premier exemple montre comment allouer de la mémoire pour une seule structure etudiant et comment saisir les champs de cette structure via un pointeur.

#include 
#include 

struct etudiant {
    int numins;
    char nom[20];
};

int main() {
    struct etudiant *p = NULL;
    
    // Allocation dynamique de mémoire pour une structure etudiant
    p = (struct etudiant *)malloc(sizeof(struct etudiant));
    if (p == NULL) {
        printf("Échec de l'allocation mémoire.\n");
        return 1;
    }
    
    // Saisie des champs de la structure
    printf("\nDonner le numéro d'inscription de l'étudiant: ");
    scanf("%d", &(p->numins));
    
    printf("\nDonner le nom de l'étudiant: ");
    fflush(stdin);  // Vide le tampon d'entrée
    gets(p->nom);
    
    // Affichage des données saisies
    printf("\nNuméro d'inscription: %d", p->numins);
    printf("\nNom de l'étudiant: %s\n", p->nom);
    
    // Libération de la mémoire allouée
    free(p);

    return 0;
}

• Exemple :02

• Allocation Dynamique d'un Tableau de Structures
• Ce second exemple montre comment allouer de la mémoire pour un tableau de structures etudiant et comment saisir les champs de chaque structure dans le tableau via un pointeur.

#include 
#include 

struct etudiant {
    int numins;
    char nom[20];
};

int main() {
    struct etudiant *classe = NULL;
    int i, n;
    
    printf("\nDonner le nombre des étudiants: ");
    scanf("%d", &n);
    
    // Allocation dynamique de mémoire pour un tableau de n structures etudiant
    classe = (struct etudiant *)malloc(n * sizeof(struct etudiant));
    if (classe == NULL) {
        printf("Échec de l'allocation mémoire.\n");
        return 1;
    }
    
    // Saisie des champs de chaque structure dans le tableau
    for (i = 0; i < n; i++) {
        printf("\nDonner le numéro d'inscription de l'étudiant: ");
        scanf("%d", &((classe + i)->numins));
        
        printf("\nDonner le nom de l'étudiant: ");
        fflush(stdin);  // Vide le tampon d'entrée
        gets((classe + i)->nom);
    }
    
    // Affichage des données d'un étudiant spécifique
    printf("\nDonner l'indice de l'étudiant: ");
    scanf("%d", &i);
    if (i >= 0 && i < n) {
        printf("\nLe numéro d'inscription de l'étudiant est %d", (classe + i)->numins);
        printf("\nLe nom de l'étudiant est %s\n", (classe + i)->nom);
    } else {
        printf("\nIndice invalide\n");
    }
    
    // Libération de la mémoire allouée
    free(classe);
    
    return 0;
}

2. Explications des Concepts

• Allocation Dynamique d'une Structure :
• La fonction malloc est utilisée pour allouer de la mémoire pour une structure. Le pointeur retourné est de type void*, il est donc nécessaire de le convertir au type approprié (par exemple, (struct etudiant *)).
• Saisie et Accès aux Champs d'une Structure :
• On utilise l'opérateur -> pour accéder aux champs d'une structure pointée par un pointeur.
• Allocation Dynamique d'un Tableau de Structures :
• La fonction malloc est utilisée pour allouer de la mémoire pour un tableau de structures. La taille totale allouée est n * sizeof(struct etudiant), où n est le nombre de structures dans le tableau.
• Les éléments du tableau sont accédés en utilisant l'arithmétique des pointeurs, par exemple (classe + i)->numins.
• Libération de la Mémoire :
• Toute mémoire allouée dynamiquement doit être libérée avec free pour éviter les fuites de mémoire.

3. Notes Importantes

• Vérification de l'Allocation : Toujours vérifier que malloc n'a pas renvoyé NULL, ce qui indiquerait un échec de l'allocation de mémoire.
• Utilisation de fflush(stdin) : fflush(stdin) est souvent utilisé pour vider le tampon d'entrée avant de lire une chaîne de caractères avec gets. Notez que fflush(stdin) est un comportement non standard et n'est pas portable ; une alternative plus portable serait d'utiliser fgets à la place de gets.
• Ces exemples montrent comment gérer la mémoire dynamique en C pour des structures, permettant une gestion flexible et efficace des données en fonction des besoins de l'application.