Cours 11.4. Incrémentation des pointeurs

Explication

Lorsqu'un pointeur est incrémenté (ptr+1) son adresse est avancée du nombre d'octets du type pointé. Considérons la taille (classique) des types suivants :

Type	Taille
`short`	2 octets
`long`	8 octets

Le code suivant avance l'adresse pointée de 2 octets :

short *ptr;
...
// Avance de deux octets (sizeof(short))
ptr++;

Le code suivant avance l'adresse pointée de 8 octets :

long *ptr;
...
// Avance de 8 octets (sizeof(long))
ptr++;

Exemple

Le code suivant affiche l'adresse de 4 pointeurs (*char, *short, *int et *long) avant et après incrémentation.

printf ("Avant, *char  = %p\n",   pChar);
printf ("Après, *char  = %p\n\n", pChar+1);

printf ("Avant, *short = %p\n",   pShort);
printf ("Après, *short = %p\n\n", pShort+1);

printf ("Avant, *int   = %p\n",   pInt);
printf ("Après, *int   = %p\n\n", pInt+1);

printf ("Avant, *long  = %p\n",   pLong);
printf ("Après, *long  = %p\n\n", pLong+1);

On vérifie que les adresses sont avancées de la taille du type pointé :

Avant, *char  = 0x7ffd8f06531b
Après, *char  = 0x7ffd8f06531c (+1 octet)

Avant, *short = 0x7ffd8f06530e
Après, *short = 0x7ffd8f065310 (+2 octets)

Avant, *int   = 0x7ffd8f0652fc
Après, *int   = 0x7ffd8f065300 (+4 octets)

Avant, *long  = 0x7ffd8f0652e8
Après, *long  = 0x7ffd8f0652f0 (+8 octets)

Tester l'exemple en ligne

Pointeurs vers des tableaux

Le nom d'un tableau utilisé sans les accolades est un pointeur vers la première cellule du tableau. Considérons la déclaration suivante :

int t[10];

t est équivalent à &t et &t[0]. C'est la raison pour laquelle tab1=tab2 ne recopie pas le tableau tab2 dans le tableau tab1. Cette écriture est à proscrire.

Pour les tableaux, le concept reste le même : on avance de la taille du type pointé. Par exemple :

// Tableau de 2 cellules
int tab[2] = {2,4};

// Première cellule du tableau
printf ("*tab     = tab[0] = %d\n", *tab);
// Deuxième cellule du tableau
printf ("*(tab+1) = tab[1] = %d\n", *(tab+1));

*ptr     = tab[0] = 2
*(ptr+1) = tab[1] = 4

On constate que le pointeur, augmenté de 1, adresse la deuxième cellule du tableau.

Tester l'exemple en ligne

Toutefois, il y a une subtilité pour les tableaux multidimensionnels : le pointeur avance d'un dans la dimension principale (typiquement une ligne) et non d'une cellule.

Exercices

Exercice 1

Écrire un programme qui

déclare un tableau de caractères de 4 lignes par 6 colonnes ;
affiche l'adresse du tableau ;
affiche l'adresse du tableau augmentée de 1.

De combien d'octets le pointeur a avancé ? Que conclure ?

Avant : 0x7ffddefd68f0
Après : 0x7ffddefd68f6

Faire l'exercice

Solution

Exercice 2

On donne les déclarations suivantes :

char text[10] = "Hello", *ptr;

Afficher chaque lettre de text séparée d'une tabulation. Vous ne devez pas utiliser :

les crochets [ et ] ;
de variables supplémentaires ;
la bibliothèque string.h.

Utiliser uniquement les pointeurs. Voici le résultat escompté :

H   e   l   l   o

Faire l'exercice

Solution

Quiz

De combien d'octets avance un pointeur incrémenté de 1 ?

de 1 octet

de 2 octets

de 4 octets

ça dépend du type pointé

Vérifier

Qu'affiche le code suivant ?

short tab[]={1,2,3};
*(tab+2)=4;
printf ("tab[2] = %d", tab[2]);

tab[2] = 1

tab[2] = 2

tab[2] = 3

tab[2] = 4

Vérifier

Concernant le programme suivant :

short tab1[]={1,2,3}, tab2[]={1,2,3};

if (tab1==tab2)
  printf ("Pareil\n");
else 
  printf ("Pas pareil\n");

le code ne compile pas.

le programme affiche : Pareil

le programme affiche : Pas pareil

on ne devrait jamais écrire une horreur pareille

Vérifier

Cours 11.3 Sommaire Cours 11.5

Voir aussi

Dernière mise à jour : 30/11/2022