Cours 11.2. Syntaxe des pointeurs en C

L'esperluette « & »

Vous l'ignorez sans-doute, mais vous avez très certainement déjà utilisé des pointeurs :

scanf("%d", &n);

Le & (et commercial ou esperluette) placé devant une variable signifie que l'on utilise son adresse. La fonction scanf() reçoit l'adresse de la variable, ce qui permet de modifier son contenu pour y écrire la saisie de l'utilisateur.

Lorsque l'on oublie le & dans un scanf(), la fonction prend pour adresse la valeur de la variable. Si la variable contient 0, la fonction va tenter d'écrire dans le premier octet de la mémoire ce qui engendre généralement une erreur de segmentation.

L'exemple ci-dessous affiche l'adresse de la variable x:

var x;
printf ("%p", &x);

La déclaration d'un pointeur

Il est possible de déclarer un pointeur, c'est-à-dire une variable destinée à contenir l'adresse d'une autre variable. Il suffit d'ajouter un astérisque devant le nom du pointeur :

int *adresse1;
char *adresse2; 

Un pointeur est toujours associé à un type. Comme le pointeur ne contient que l'adresse du premier octet, la désignation du type permet au compilateur de connaître la taille de la variable pointée. Dans l'exemple suivant, le pointeur adresse contient l'adresse de la variable var. On dit que var est pointée par le pointeur adresse ou que adresse pointe vers var :

float var;
float *adresse = &var;

Accès à la variable pointée

L'intérêt des pointeurs est de pouvoir accéder à une variable en lecture et/ou en écriture par son adresse. L'accès au contenu pointé se fait en ajoutant un astérisque devant le pointeur :

float var;
float *adresse = &var;
*adresse = 5.2;  // Equivalent à var=5.2;

Exemple

Voici un exemple des différentes syntaxes pour les pointeurs :

  // Déclare une variable 
  short var=0xABCD;
  // Déclare un pointeur vers var
  short* adresse = &var; 

  // Affiche la variable var
  printf ("var      : %hX\n", var);

  // Affiche le contenu pointé (= var)
  printf ("*adresse : %hX\n", *adresse);

  // Affiche l'adresse de var
  printf ("&var     : %p\n", &var);

  // Affiche le contenu du pointeur (adresse de var)
  printf ("adresse  : %p\n", adresse);

  // Affiche l'adresse du pointeur
  printf ("&adresse : %p\n", &adresse);

Voici un affichage possible pour ce programme :

var      : ABCD
*adresse : ABCD
&var     : 0x7ffcda51423a
adresse  : 0x7ffcda51423a
&adresse : 0x7ffcda514230

L'image suivante illustre la représentation de la mémoire pour cette exécution du programme. On retrouve bien les deux entités principales :

• la variable var
• le pointeur adresse

On constate que le contenu du pointeur est bien l'adresse de var. Le pointeur adresse pointe sur la variable var :

Exercices

Exercice 1

Écrire une programme qui

• déclare un entier var et l'initialise à 18 ;
• déclare un pointeur d'entier adresse ;
• affecte l'adresse de varau pointeur ;
• affiche var
• affiche la variable pointée par adresse (*adresse).

var = 18
*adresse = 18

#include <stdio.h> int main(void) { // Déclare un entier `var` et l'initialise à 18 // COMPLETER ICI // Déclare un pointeur d'entier `adresse` // COMPLETER ICI // Affecte l'adresse de `var`au pointeur // COMPLETER ICI // affiche `var` et la variable pointée par `adresse` (`*adresse`) // COMPLETER ICI return 0; }

Exercice 2

Écrire une programme qui

• déclare un entier var et l'initialise à 27 ;
• déclare un pointeur d'entier adresse ;
• affecte l'adresse de varau pointeur ;
• affiche l'adresse contenue dans le pointeur ;
• ajoute 1 au pointeur ;
• affiche l'adresse contenue dans le pointeur.

On constate que le pointeur n'a pas été augmenté d'un octet, mais de 4 octets, ce qui correspond à la taille d'un entier :

Avant : 0x7ffe4b0a7e88
Après : 0x7ffe4b0a7e8c

#include <stdio.h> int main(void) { // Déclare un entier var et l'initialise à 27 ; // COMPLETER ICI // Déclare un pointeur d'entier adresse ; // COMPLETER ICI // Affecte l'adresse de varau pointeur ; // COMPLETER ICI // Affiche l'adresse contenue dans le pointeur ; // COMPLETER ICI // Ajoute 1 au pointeur ; // COMPLETER ICI // Affiche l'adresse contenue dans le pointeur. // COMPLETER ICI return 0; }

Quiz

Comment obtenir l'adresse d'une variable ?

---

Quelles syntaxes permettent de déclarer un pointeur ?

---

Comment afficher le contenu de la variable pointée par le pointeur ad ?

---

Comment afficher l'adresse contenue dans le pointeur ad ?

---

Comment afficher l'adresse du pointeur ad ?

---

Qu'affiche le programme suivant ?

int var = 128, *adresse;
adresse = &var;
printf ("%d %d", var, *adresse);

---

Qu'affiche le programme suivant ?

int var = 128, *adresse;
adresse = &var;
printf ("%p", adresse);

---

Un pointeur est associés à un type ...

---

Voir aussi

• Cours de programmation en C
• Cours 1.1. Histoire du C
• Cours 1.2. Premier programme
• Cours 1.3. Compilation
• Cours 1.4. Les directives de compilation
• Cours 1.5. Quel compilateur choisir ?
• Cours 1.6. Les organigrammes
• Cours 2.1. Les types de variables
• Cours 2.2. Les entiers
• Cours 2.3. Les nombres décimaux
• Cours 2.4. Les caractères
• Cours 2.5. Initialisation des variables
• Cours 2.6. Le vol 501 d'Ariane
• Cours 3.1. Les opérateurs arithmétiques
• Cours 3.2. Le modulo
• Cours 3.3. Le type dans les opérations
• Cours 3.4. Les conversion de type forcé
• Cours 3.5. Les opérateurs bit à bit
• Cours 3.6. Détail des opérateurs bit à bit
• Cours 3.7. Opérateurs de décalage
• Cours 3.8. Opérateurs d'affectation
• Cours 3.9. Opérateur d'incrémentation/décrémentation
• Cours 3.10. Les opérateurs de comparaison
• Cours 3.11. Opérateurs logiques
• Cours 3.12. Priorité des opérateurs
• Cours 4.1. printf
• Cours 4.2. scanf
• Cours 4.3. putchar
• Cours 5.1. Branchement conditionnel (if...else)
• Cours 5.2. if imbriqués et indentation
• Cours 5.3. Tester des intervalles
• Cours 5.4. Opérateur conditionnel ternaire ( ?: )
• Cours 5.5. L'instruction switch..case
• Cours 5.6. Le break dans les switchs
• Cours 6.1. La boucle do..while en C
• Cours 6.2. La boucle while en C
• Cours 6.3. La boucle for
• Cours 6.4. Comment choisir une boucle en C ?
• Cours 6.5. Exercices sur les boucles en C
• Cours 7.1. Masquages
• Cours 7.2. Masquage : forçage à zéro
• Cours 7.3. Forçage à un
• Cours 7.4. Inversion de bits
• Cours 7.5. Tester un bit
• Cours 7.6. Synthèse des masquages
• Cours 8.1. Syntaxe des fonctions en C
• Cours 8.2. L'appel des fonctions
• Cours 8.3. Le mot-clé void dans les fonctions
• Cours 8.4. Le mot-clé return dans les fonctions
• Cours 8.5. Portée des variables
• Cours 8.6. Les variables globales
• Cours 8.7. Les variables statiques
• Cours 8.8. Nombres aléatoires en C
• Cours 8.9. Fonctions mathématiques en C
• Cours 9.1. Syntaxe des tableaux en C
• Cours 9.2. Initialisation des tableaux en C
• Cours 9.3. Les tableaux multidimensionnels en C
• Cours 9.4. Comment les tableaux sont stockés en mémoire en C?
• Cours 9.5. Les tableaux dans les fonctions
• Cours 9.6. Exercices sur les tableaux en C
• Cours 10.1. Les chaines de caractères en C
• Cours 10.2. Le caractère de fin de chaîne
• Cours 10.3. La bibliothèque string.h
• Cours 10.4. Chaînes de caractères et fonctions
• Cours 11.1. Introduction aux pointeurs en C
• Cours 11.3. Allocation mémoire dynamique
• Cours 11.4. Incrémentation des pointeurs
• Cours 11.5. Passage de paramètres par pointeur
• Cours 12.1. Introduction aux structures en C
• Cours 12.2. Propriétés des structures en C
• Cours 12.3. Structures et pointeurs
• Cours 12.4. Structures et fonctions
• Cours 13.1. Fonctions récursives en C
• Cours 13.2. Profondeur des fonctions récursives
• Cours 13.3. Récursion croisée
• Cours 14.1. Exercices complémentaires

---