Cours Programmation en Langage C - Chapitre 6 : Les Pointeurs

Ce cours couvre les notions fondamentales des pointeurs en langage C, destinées aux étudiants de première année en informatique appliquée. Il explique l’adressage direct et indirect, les opérateurs associés aux pointeurs, leur relation avec les tableaux, ainsi que l’arithmétique des pointeurs. Des exemples concrets illustrent chaque concept pour faciliter la compréhension.

Adressage direct

En programmation, une variable stocke une valeur à une adresse mémoire spécifique. L’adressage direct consiste à accéder au contenu d’une variable en utilisant son nom.

int a = 10;
printf("%d", a);   // affichage : 10
printf("%p", &a);  // affichage : adresse mémoire de a, par exemple F800

Adressage indirect

L’adressage indirect utilise un pointeur, une variable spéciale qui contient l’adresse d’une autre variable. On peut ainsi accéder à la valeur d’une variable en passant par son pointeur.

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

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

Quand q pointe sur a, *q donne la valeur de a.

Définition : Pointeur

Un pointeur est une variable qui contient l’adresse d’une autre variable. En C, chaque pointeur est typé, c’est-à-dire qu’il ne peut contenir que l’adresse d’une variable du même type. Si q contient l’adresse de a, on dit que q pointe sur a.

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

• Opérateur adresse : &
  &NomVariable donne l’adresse de la variable. Par exemple, &a est l’adresse de a.
• Opérateur contenu : *
  *NomPointeur donne le contenu de l’adresse pointée par le pointeur. Par exemple, *q donne la valeur de la variable pointée par q.
• Déclaration d’un pointeur :
  Type *NomPointeur; déclare un pointeur sur un type donné. Par 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 * et & ont la même priorité que !, ++, -- et s’évaluent de droite à gauche.

Si P pointe sur X, alors *P peut être utilisé partout où X est utilisé.

P = &X;
Y = *P + 1;   // équivalent à Y = X + 1;
*P = *P + 10; // équivalent à X = X + 10;
*P += 2;      // équivalent à X += 2;
++*P;         // équivalent à ++X;
(*P)++;       // équivalent à X++;

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 le même objet que le second.

Pointeurs et tableaux

Le nom d’un tableau est un pointeur constant vers son premier élément :

• tab est équivalent à &tab[0]
• tab[i] est équivalent à *(tab + i)
• &tab[i] est équivalent à tab + i

Exemple :

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

tab    == &tab[0]  == adresse F800
tab+1  == &tab[1]  == adresse F810
tab+2  == &tab[2]  == adresse F820

*tab   == tab[0]   == 11
*(tab+1) == tab[1] == 12
*(tab+2) == tab[2] == 13

Attention : Le nom du tableau tab ne change jamais de valeur (adresse).

Exemple d’utilisation d’un pointeur avec 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

Exemple avec déplacement du pointeur

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

Incrémentation d’un pointeur

q = tab;
q++;  // q pointe maintenant sur tab[1]

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

Opérations sur pointeurs dans un tableau

Pour un pointeur q pointant sur un élément quelconque d’un tableau :

• q + i pointe sur l’élément situé à l’indice i après q
• q - i pointe sur l’élément situé à l’indice i avant q
• Les opérations q++, q+=n, q--, q-=n sont valides et déplacent le pointeur dans le tableau.

Résumé sur pointeurs et tableaux

int tab[10];
int *q;

q = tab;    // équivalent à q = &tab[0];
*(q + i)   // contenu de tab[i]

Le compilateur calcule automatiquement l’adresse q + i en ajoutant à q la taille d’une composante multipliée par i.

Remarque : Un pointeur est une variable modifiable, alors que le nom d’un tableau est une constante. Par conséquent, q++ est permis, mais tab++ est interdit.

Formalismes tableau et pointeur

Un programme utilisant la notation tableau peut être traduit en notation pointeur en remplaçant systématiquement tab[i] par *(tab + i).

Exemple : remplissage et affichage d’un tableau

#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]);
}

Version équivalente en formalisme pointeur :

#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 sur le 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-- sur l’élément précédent, et de même pour P += n et P -= n.

Domaine des opérations : Ces opérations sont définies uniquement à l’intérieur d’un tableau. Dépasser les limites du tableau conduit à un comportement indéfini.

Exemples

int A[10];
int *P;

P = A + 9;   // légal : dernier élément
P = A + 11;  // illégal : dépassement
P = A - 1;   // illégal : avant début du tableau

Soustraction de pointeurs

Si P1 et P2 pointent dans le même tableau, alors P1 - P2 donne le nombre d’éléments entre eux :

• Résultat négatif si P1 précède P2
• Résultat nul si P1 et P2 pointent sur le même élément
• Résultat positif si P2 précède P1
• Indéfini si P1 et P2 ne pointent pas dans le même tableau

Comparaison de pointeurs

On peut comparer deux pointeurs avec <, >, <=, >=, ==, !=. Si les pointeurs pointent dans le même tableau, la comparaison correspond à celle des indices.

Exemple d’utilisation d’un pointeur pour parcourir un tableau

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

    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++)
        printf("l'element est %d \n", *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 contenant l’adresse d’une autre variable.
• Opérateur & : Opérateur qui donne l’adresse d’une variable.
• Opérateur * : Opérateur qui donne le contenu de l’adresse pointée par un pointeur.
• Déclaration de pointeur : Syntaxe Type *NomPointeur; pour déclarer un pointeur sur un type donné.
• Tableau : Ensemble contigu d’é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, décrémentation sur des pointeurs, respectant le type pointé.
• Nom de tableau : Pointeur constant vers le premier élément du tableau.

Points clés à retenir

• Un pointeur contient l’adresse d’une variable et permet d’y accéder indirectement.
• Les opérateurs & (adresse) et * (contenu) sont essentiels pour manipuler les pointeurs.
• Le nom d’un tableau est un pointeur constant vers son premier élément.
• Les expressions tab[i] et *(tab + i) sont équivalentes.
• L’arithmétique des pointeurs permet de naviguer dans un tableau en décalant le pointeur.
• Les opérations sur pointeurs doivent rester dans les limites du tableau pour éviter un comportement indéfini.
• Un pointeur peut être incrémenté ou affecté, contrairement au nom d’un tableau qui est constant.
• La comparaison et la soustraction de pointeurs sont définies uniquement pour des pointeurs dans le même tableau.