Introduction à l'adressage mémoire

L'architecture fondamentale de la mémoire d'un ordinateur repose sur des unités de stockage appelées octets. Chaque octet représente la plus petite unité de mémoire directement adressable et se voit attribuer une adresse unique. Cette adresse sert de référence pour le processeur afin de localiser et d'interagir avec les données stockées à cet emplacement.

La taille d'une adresse mémoire varie selon l'architecture du système :

• Sur une machine 32 bits, les adresses sont encodées sur 32 bits, occupant ainsi 4 octets.
• Sur une machine 64 bits, les adresses sont encodées sur 64 bits, soit 8 octets.

Cette correspondance entre les adresses et les cellules mémoire peut être imaginée comme une suite linéaire de boîtes numérotées, où chaque numéro est une adresse et chaque boîte contient un octet de données.

En langage C, un pointeur est fondamentalement une adresse mémoire. Cependant, dans la pratique courante, le terme "pointeur" désigne généralement une *variable de type pointeur*, dont le rôle est de conserver l'adresse d'une autre entité en mémoire. Par exemple :

int valeur_nombre = 10;          // Déclare une variable entière nommée 'valeur_nombre'
int *ptr_vers_nombre = &valeur_nombre; // Déclare un pointeur sur entier 'ptr_vers_nombre' et lui assigne l'adresse de 'valeur_nombre'.

Dans l'exemple ci-dessus, valeur_nombre contient la donnée entière 10. La variable ptr_vers_nombre, quant à elle, ne stocke pas la valeur 10, mais l'adresse mémoire où la valeur 10 est stockée. Sur une machine 32 bits, valeur_nombre occupe 4 octets pour la donnée, et ptr_vers_nombre occupe 4 octets pour l'adresse.

Indépendamment du type de donnée qu'elle pointe (entier, flottant, caractère, etc.), la taille d'une variable pointeur est constante et déterminée par l'architecture du système d'exploitation.

• Sur une machine 32 bits, toute variable pointeur occupe 4 octets.
• Sur une machine 64 bits, toute variable pointeur occupe 8 octets.

Bien que toutes les variables pointeurs aient la même taille pour stocker une adresse, leur type (par exemple, int*, char*, float*) est crucial pour deux raisons principales :

1. Déterminer l'étendue de l'accès lors du déréférencement

Lorsque l'opérateur de déréférencement (*) est utilisé sur un pointeur, le type du pointeur indique combien d'octets doivent être lus ou écrits à partir de l'adresse qu'il contient.

Considérons une valeur stockée en mémoire :

unsigned int ma_valeur = 0x11223344; // Une valeur entière non signée
printf("Avant modification : 0x%X\n", ma_valeur);

unsigned int *ptr_int = &ma_valeur;
*ptr_int = 0; // Le déréférencement d'un int* accède à 4 octets
printf("Après *ptr_int = 0 : 0x%X\n", ma_valeur); // Affiche 0x00000000

Si nous utilisons un pointeur de type char* :

unsigned int ma_valeur = 0x11223344;
char *ptr_char = (char *)&ma_valeur; // Cast explicite en char*
printf("Avant modification : 0x%X\n", ma_valeur);
*ptr_char = 0; // Le déréférencement d'un char* accède à 1 octet
printf("Après *ptr_char = 0 : 0x%X\n", ma_valeur); // Affiche 0x11223300 (sur une architecture little-endian)

2. Déterminer le pas d'incrémentation (arithmétique de pointeurs)

Lorsqu'une opération arithmétique (comme l'addition ou la soustraction) est effectuée sur un pointeur, le type du pointeur détermine la taille du "pas". Incrémenter un pointeur de 1 le fait avancer du nombre d'octets correspondant à la taille du type qu'il pointe.

#include <stdio.h>

int main() {
    int tableau_entiers[2] = {10, 20};
    int *ptr_entier = tableau_entiers; // ptr_entier pointe sur tableau_entiers[0]

    char tableau_caracteres[2] = {'A', 'B'};
    char *ptr_caractere = tableau_caracteres; // ptr_caractere pointe sur tableau_caracteres[0]

    printf("Adresse initiale (int*) : %p\n", (void*)ptr_entier);
    printf("Adresse après ptr_entier + 1 : %p (saut de %zu octets)\n", (void*)(ptr_entier + 1), sizeof(int));
    // ptr_entier + 1 avance de sizeof(int) octets (généralement 4).

    printf("Adresse initiale (char*) : %p\n", (void*)ptr_caractere);
    printf("Adresse après ptr_caractere + 1 : %p (saut de %zu octets)\n", (void*)(ptr_caractere + 1), sizeof(char));
    // ptr_caractere + 1 avance de sizeof(char) octets (toujours 1).

    return 0;
}

Les pointeurs "fous" (ou "dangling pointers")

Un pointeur "fou" est un pointeur qui référence une zone mémoire invalide ou qui n'est plus attribuée au programme. Tenter de déréférencer un tel pointeur conduit à un comportement indéfini, souvent à un crash du programme ou à des corruptions de données.

Causes courantes des pointeurs fous

1. **Pointeur non initialisé :**Un pointeur déclaré sans initialisation contient une adresse aléatoire (une "valeur indéterminée"). Tenter d'y écrire est une erreur.

   int main() {
       int *ptr_aleatoire; // Le pointeur n'est pas initialisé, il contient n'importe quelle adresse.
       // *ptr_aleatoire = 100; // Déréférencer ici est une faute grave et peut provoquer un crash.
       // Cette ligne est commentée pour éviter un comportement indéfini.
       return 0;
   }
   
   

2. **Accès hors limites :**Lorsqu'un pointeur est utilisé pour accéder à une zone mémoire au-delà des limites allouées (par exemple, la fin d'un tableau), il devient "fou".

   int main() {
       int tableau_valeurs[3] = {0}; // Un tableau de 3 entiers (indices 0, 1, 2)
       int *ptr_tab = tableau_valeurs; // ptr_tab pointe vers tableau_valeurs[0]
   
       for (int i = 0; i <= 3; ++i) { // La boucle devrait s'arrêter à i < 3
           *(ptr_tab + i) = i * 10; // Accès hors limites lorsque i = 3 (tentative d'accès à tableau_valeurs[3])
       }
       // L'accès à tableau_valeurs[3] est une erreur d'accès mémoire.
       return 0;
   }
   
   

3. **Pointeur vers de la mémoire libérée :**Un pointeur devient "fou" si la mémoire à laquelle il référait a été libérée ou n'est plus valide pour le programme, comme une variable locale de fonction après la fin de son exécution.

   int* creer_entier_local() {
       int valeur_temporaire = 50; // 'valeur_temporaire' est une variable locale
       return &valeur_temporaire;  // Retourne l'adresse d'une variable qui sera détruite à la sortie de la fonction
   }
   
   int main() {
       int *ptr_invalide = creer_entier_local();
       // À ce stade, 'valeur_temporaire' n'existe plus en mémoire valide.
       // 'ptr_invalide' pointe désormais vers une zone mémoire potentiellement réutilisée ou interdite.
       // *ptr_invalide = 123; // Tenter de déréférencer ici est un comportement indéfini et dangereux.
       // Cette ligne est commentée pour éviter un problème.
       return 0;
   }
   
   

Méthodes pour éviter les pointeurs fous

Pour écrire du code C robuste et fiable, il est essentiel de gérer les pointeurs avec soin :

• Initialiser les pointeurs : Toujours initialiser un pointeur dès sa déclaration. Si la destination n'est pas encore connue, assignez-lui la valeur NULL (ou nullptr en C++).
• Vérifier les limites d'accès : Soyez extrêmement vigilant lors des opérations d'arithmétique de pointeurs, en particulier avec les tableaux, pour ne jamais dépasser les frontières des blocs mémoire alloués.
• Mettre les pointeurs à NULL après libération : Une fois qu'une zone mémoire pointée a été libérée (par exemple, avec free()), assignez immédiatement NULL au pointeur correspondant. Cela empêche de déréférencer accidentellement cette zone.
• Éviter de retourner des adresses de variables locales : Ne jamais renvoyer l'adresse d'une varible locale à une fonction appelante, car cette mémoire sera désallouée dès que la fonction se termine.
• Valider les pointeurs avant utilisation : Avant de déréférencer un pointeur, vérifiez toujours qu'il n'est pas NULL et qu'il est censé pointer vers une zone mémoire valide.