Les Pointeurs en Langage C

Ce matériel couvre les concepts fondamentaux des pointeurs en langage C, destinés aux étudiants de première année en informatique appliquée. Il explique l'adressage direct et indirect, les opérateurs de base, les relations entre pointeurs et tableaux, ainsi que l'arithmétique des pointeurs avec des exemples pratiques.

Adressage direct et indirect

En programmation, une variable stocke une valeur à une adresse spécifique en mémoire. L'adressage direct consiste à accéder à cette valeur via le nom de la variable.

int a = 10;
printf("%d", a);   // affiche : 10
printf("%p", &a);  // affiche l'adresse de a, par exemple F800

L'adressage indirect utilise un pointeur, une variable spéciale qui contient l'adresse d'une autre variable. Par exemple, si a contient 10, un pointeur q peut contenir l'adresse de a et permettre d'accéder à sa valeur via *q.

int a = 10;
int *q;
q = &a;

printf("%d", a);    // 10
printf("%p", &a);   // adresse de a, ex: F802H
printf("%p", q);    // même adresse que &a : F802H
printf("%p", &q);   // adresse de q, différente : ex F400H
printf("%d", *q);   // 10, contenu pointé par q

Définition : Un pointeur est une variable qui contient l'adresse d'une autre variable. Chaque pointeur est typé, c'est-à-dire qu'il pointe uniquement vers des variables d'un type donné.

Remarque : Le nom d'une variable est lié à une adresse fixe, tandis qu'un pointeur peut changer d'adresse pointée.

Les opérateurs de base des pointeurs

• Opérateur adresse de : &
  Permet d'obtenir l'adresse d'une variable.
  Exemple : &a donne l'adresse de a.
• Opérateur contenu de : *
  Permet d'accéder à la valeur stockée à l'adresse pointée par un pointeur.
  Exemple : *q donne la valeur pointée par q.
• Déclaration d'un pointeur :
  Type *NomPointeur; déclare un pointeur sur un type donné.
  Exemple : int *q; déclare un pointeur sur un entier.

Attention : L'opérateur & ne peut s'appliquer qu'à des variables ou tableaux, pas à des constantes ou expressions.

Opérations élémentaires sur pointeurs

Les opérateurs unaires * (contenu) et & (adresse) ont la même priorité et s'évaluent de droite à gauche. Si P pointe sur X, alors *P peut être utilisé partout où X est utilisable.

Exemple d'équivalence après P = &X; :

• Y = *P + 1; équivaut à Y = X + 1;
• *P = *P + 10; équivaut à X = X + 10;
• *P += 2; équivaut à X += 2;
• ++*P; équivaut à ++X;
• (*P)++; équivaut à X++; (parenthèses nécessaires)

On ne peut affecter qu'une adresse à un pointeur. Deux pointeurs du même type peuvent être affectés l'un à l'autre, ce qui fait pointer le premier sur la même adresse que le second.

Pointeurs et tableaux

Le nom d'un tableau représente l'adresse de son premier élément. Ainsi, tab et &tab[0] désignent la même adresse.

On peut écrire :

• tab[i] équivaut à *(tab + i)
• &tab[i] équivaut à tab + i

Exemple avec un tableau :

int tab[5] = {11, 12, 13, 14, 15};

tab      = adresse F800 (exemple)
tab + 1  = adresse F810
tab + 2  = adresse F820
tab + 3  = adresse F830
tab + 4  = adresse F840

*tab      = 11
*(tab+1)  = 12
*(tab+2)  = 13
*(tab+3)  = 14
*(tab+4)  = 15

Attention : La valeur de tab ne change jamais, c'est un pointeur constant vers le premier élément.

Exemple d'utilisation d'un pointeur sur un tableau

int tab[5] = {11, 12, 13, 14, 15};
int *q;
q = tab;  // q pointe sur tab[0]

printf("%d\n", *q);     // 11
printf("%d\n", *(q+1)); // 12
printf("%d\n", *(q+4)); // 15

q = tab + 2;  // q pointe sur tab[2]
printf("%d\n", *q);     // 13
printf("%d\n", *(q+1)); // 14
printf("%d\n", *(q-2)); // 11

q = tab;
q++;          // q pointe maintenant sur tab[1]
printf("%d\n", *q);     // 12

On peut aussi modifier la position du pointeur par addition ou soustraction :

• q += 3; fait pointer q sur l'élément 3 positions après
• q -= 2; fait pointer q sur l'élément 2 positions avant

Formalismes tableau et pointeur

Un programme utilisant la notation tableau tab[i] peut être converti en notation pointeur *(tab + i).

Exemple :

#include <stdio.h>
void main() {
    int tab[50];
    int i, n;

    printf("saisir la taille du tableau  ");
    scanf("%d", &n);

    for (i = 0; i < n; i++)
        scanf("%d", &tab[i]);

    for (i = 0; i < n; i++)
        printf("l'element d'indice %d est %d \n", i, tab[i]);
}

Peut être réécrit en :

#include <stdio.h>
void main() {
    int tab[50];
    int i, n;

    printf("saisir la taille du tableau  ");
    scanf("%d", &n);

    for (i = 0; i < n; i++)
        scanf("%d", tab + i);

    for (i = 0; i < n; i++)
        printf("l'element d'indice %d est %d \n", i, *(tab + i));
}

Arithmétique des pointeurs

Le langage C permet des opérations arithmétiques sur les pointeurs, toujours en tenant compte du type pointé :

• Affectation : Si P1 et P2 sont pointeurs du même type, P1 = P2; fait pointer P1 sur le même objet que P2.
• Addition et soustraction : Si P pointe sur A[i], alors P + n pointe sur A[i+n], et P - n sur A[i-n].
• Incrémentation et décrémentation :
  P++ fait pointer P sur l'élément suivant,
  P += n sur l'élément n positions plus loin,
  P-- et P -= n font pointer P sur les éléments précédents.

Attention : Ces opérations sont valides uniquement à l'intérieur des limites du tableau. Sortir de ce domaine conduit à un comportement indéfini.

Exemple d'utilisation

int A[10];
int *P;

P = A + 9;   // pointeur sur dernier élément : légal
P = A + 11;  // hors limites : illégal
P = A - 1;   // hors limites : illégal

Soustraction et comparaison de pointeurs

Si P1 et P2 pointent dans le même tableau :

• P1 - P2 donne le nombre d'éléments entre P1 et P2.
• Le résultat est négatif si P1 précède P2, zéro s'ils sont égaux, positif si P2 précède P1.
• Comparer deux pointeurs (<, >, ==, etc.) revient à comparer leurs indices dans le tableau.

Exemple d'utilisation dans une boucle

#include <stdio.h>
void main() {
    int tab[50];
    int n, *q, i = 0;

    printf("saisir la taille du tableau  ");
    scanf("%d", &n);

    for (q = tab; q < tab + n; q++)
        scanf("%d", q);

    for (q = tab; q < tab + n; q++, i++)
        printf("l'element d'indice %d est %d \n", i, *q);
}

Glossaire des termes clés

• Adressage direct : Accès à la valeur d'une variable via son nom.
• Adressage indirect : Accès à la valeur d'une variable via un pointeur contenant son adresse.
• Pointeur : Variable spéciale contenant l'adresse d'une autre variable, typée selon le type pointé.
• Opérateur & : Opérateur "adresse de" qui retourne l'adresse d'une variable.
• Opérateur * : Opérateur "contenu de" qui retourne la valeur stockée à l'adresse pointée par un pointeur.
• Tableau : Structure de données contenant plusieurs éléments du même type, dont le nom représente l'adresse du premier élément.
• Arithmétique des pointeurs : Opérations d'addition, soustraction, incrémentation et décrémentation sur des pointeurs, respectant la taille des types pointés.
• Déclaration de pointeur : Syntaxe Type *NomPointeur; pour déclarer un pointeur sur un type donné.

Points clés à retenir

• Un pointeur contient l'adresse d'une variable et permet d'accéder indirectement à sa valeur.
• Les opérateurs & et * sont essentiels pour manipuler les pointeurs : & pour obtenir une adresse, * pour accéder au contenu.
• Le nom d'un tableau est un pointeur constant vers son premier élément, mais il ne peut pas être modifié comme un pointeur classique.
• On peut utiliser l'arithmétique des pointeurs pour naviguer dans un tableau de manière efficace.
• Les opérations sur pointeurs doivent toujours rester dans les limites du tableau pour éviter un comportement indéfini.
• La notation tableau tab[i] est équivalente à la notation pointeur *(tab + i).