Arithmétique des pointeurs

Fait partie de la section Logic & Flow du Journey C de Coddy — leçon 9 sur 63.

Vous avez appris à accéder aux éléments d'un tableau en utilisant la notation de pointeur comme *(array + i). Maintenant, vous allez découvrir une technique encore plus puissante : l'arithmétique des pointeurs, qui vous permet de déplacer des pointeurs dans la mémoire en utilisant de simples opérations d'incrémentation et de décrémentation.

Lorsque vous incrémentez un pointeur avec ++ ou que vous le décrémentez avec --, le pointeur ne se déplace pas simplement d'un octet. Au lieu de cela, il se déplace de la taille du type de données vers lequel il pointe. Pour un pointeur d'entier, ptr++ avance de sizeof(int) octets, arrivant exactement sur l'entier suivant en mémoire.

int numbers[5] = {10, 20, 30, 40, 50};
int *ptr = numbers;    // Pointe vers le premier élément (10)
ptr++;                 // Pointe maintenant vers le deuxième élément (20)
ptr++;                 // Pointe maintenant vers le troisième élément (30)

Ce calcul automatique de la taille est ce qui rend l'arithmétique des pointeurs si puissante et pratique. Vous n'avez pas à vous soucier des calculs d'octets - le C gère l'adressage mémoire pour vous en fonction du type de données du pointeur.

L'arithmétique des pointeurs est particulièrement utile pour parcourir des tableaux dans des boucles. Au lieu d'utiliser des indices de tableau, vous pouvez incrémenter un pointeur pour parcourir chaque élément de manière séquentielle, ce qui se traduit souvent par un code plus efficace.

Défi

Facile

Écrivez un programme en C qui démontre l'arithmétique des pointeurs en utilisant des opérations d'incrémentation de pointeur pour parcourir et traiter un tableau. Votre programme doit :

Déclarer un tableau d'entiers nommé data avec 5 éléments et l'initialiser avec les valeurs {12, 24, 36, 48, 60}
Déclarer un pointeur vers un entier nommé ptr et l'initialiser pour qu'il pointe vers le premier élément du tableau
Utiliser une boucle for qui s'exécute 5 fois pour parcourir l'ensemble du tableau en utilisant uniquement l'arithmétique des pointeurs
À l'intérieur de la boucle :
- Afficher la valeur actuelle vers laquelle ptr pointe en utilisant l'opérateur de déréférencement
- Afficher l'adresse mémoire stockée dans ptr en utilisant le spécificateur de format %p
- Incrémenter le pointeur en utilisant ptr++ pour passer à l'élément suivant
Après la boucle, réinitialiser ptr pour qu'il pointe à nouveau vers le premier élément du tableau
Utiliser l'arithmétique des pointeurs pour accéder directement et afficher le troisième élément (index 2) en utilisant *(ptr + 2)
Utiliser l'arithmétique des pointeurs pour accéder directement et afficher le dernier élément (index 4) en utilisant *(ptr + 4)

Votre sortie doit afficher les résultats dans le format suivant :

Value: 12, Address: [address]
Value: 24, Address: [address]
Value: 36, Address: [address]
Value: 48, Address: [address]
Value: 60, Address: [address]
Third element: 36
Last element: 60

Ce défi teste votre compréhension de la manière dont les opérations d'incrémentation de pointeur se déplacent automatiquement de la taille du type de données, et comment vous pouvez utiliser l'arithmétique des pointeurs pour accéder aux éléments d'un tableau à des décalages spécifiques par rapport à la position d'un pointeur de base.

Aide-mémoire

L'arithmétique des pointeurs vous permet de déplacer des pointeurs dans la mémoire à l'aide d'opérations d'incrémentation et de décrémentation. Lorsque vous incrémentez un pointeur, il se déplace de la taille du type de données vers lequel il pointe, et non d'un octet.

Opérations de base de l'arithmétique des pointeurs :

int numbers[5] = {10, 20, 30, 40, 50};
int *ptr = numbers;    // Pointe vers le premier élément (10)
ptr++;                 // Pointe maintenant vers le deuxième élément (20)
ptr++;                 // Pointe maintenant vers le troisième élément (30)

Vous pouvez également utiliser l'arithmétique des pointeurs pour accéder à des éléments à des décalages (offsets) spécifiques :

*(ptr + 2)  // Accède à l'élément au décalage 2 à partir de la position actuelle

L'arithmétique des pointeurs est utile pour parcourir des tableaux dans des boucles, ce qui permet souvent d'obtenir un code plus efficace que l'utilisation d'indices de tableau.

Essayez vous-même

#include <stdio.h>

int main() {
    // TODO: Écrivez votre code ici
    // Déclarer et initialiser le tableau 'data' avec les valeurs {12, 24, 36, 48, 60}
    // Déclarer le pointeur 'ptr' et l'initialiser pour qu'il pointe vers le premier élément
    // Utiliser une boucle for avec l'arithmétique de pointeurs pour parcourir le tableau
    // Afficher chaque valeur et adresse, puis incrémenter le pointeur
    // Réinitialiser le pointeur et utiliser l'arithmétique de pointeurs pour accéder à des éléments spécifiques
    
    return 0;
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logic & Flow

2Pointeurs et Tableaux

Noms de tableaux comme pointeurs Éléments de tableau - PointeursArithmétique des pointeursComparaison de pointeurs Récapitulatif : Parcours de tableau par pointeur

5Pointeurs et fonctions

Passage par valeur Passage de pointeurs aux fonctions Modifier des variables via des pointeurs Un exemple classique : Swap Passage de tableaux aux fonctions Récapitulatif : Pointeurs comme arguments de fonction

8Structures et Pointeurs

Pointeurs vers des structures L'opérateur flèche (->)Passage de structures par valeur Passage de pointeurs de structures Allocation dynamique de structures Récap : Modifier une structure - Ptr

11Défis de révision finale

Récap : Concaténation dynamique de chaînes Récap : Tableau de structs Récap : Compteur de fréquence des mots