FriconiX
Des milliers de pictogrammes gratuits dessinés avec amour!

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)

Pointeurs vers de 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, aumgenté de 1, adresse la deuxième cellule du tableau.

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.

Exercice

Exercice 1

Écrire un programme qui

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

Avant : 0x7ffddefd68f0
Après : 0x7ffddefd68f6

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 :

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

H   e   l   l   o

Quiz

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

Vérifier Bravo ! Essaie encore ...

Qu'affiche le code suivant ?

short tab[]={1,2,3};
*(tab+2)=4;
printf ("tab[2] = %d", tab[2]);
Vérifier Bravo ! Essaie encore ...

Concernant le programme suivant :

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

if (tab1==tab2)
  printf ("Pareil\n");
else 
  printf ("Pas pareil\n");
Vérifier Bravo ! Essaie encore ...

Voir aussi


Dernière mise à jour : 30/10/2020