Considérons le programme académique suivant s'exécutant dans un terminal, qui affiche successivement les valeurs hexadécimales des adresses des variables a, b et c dans cet ordre (cf. la ligne nº 9).

#include <stdio.h>

int   a = 2047;
short b = 5;
int   c = -10;

int main(void)
{
  printf("a: %p\nb: %p\nc: %p\n", (void *) &a, (void *) &b, (void *) &c);
  return 0;
}  

Exécuté sur OnlineGDB, ce programme produit typiquement une sortie comme :

a: 0x555f381b8010
b: 0x555f381b8014
c: 0x555f381b8018

Dans un programme académique, après une déclaration de variable globale comme :
int a = 2047;
l'expression &a prend pour valeur l'adresse de la variable a qui a attribuée par la machine lors du chargement du programme en mémoire (et pas par le codeur avant la compilation). La valeur 0x555f381b8010 affichée lors de l'exécution de l'exemple supra  n'est qu'une possibilité parmi tant d'autres .

Reprenons l'exemple académique supra  de la variable déclarée par l'instruction :
int a = 2047;

Pour mémoire, l'expression &a prend pour valeur l'adresse de a, donc l'expression *(&a) – qui se code tout simplement *&a – prend la valeur courante encodée à cette adresse, c'est‑à‑dire la valeur de la variable a, ici 2047.

Considérons les deux déclarations académiques suivantes :

int number = 5;
int * pointer = &number;

La ligne nº 6 est la déclaration d'une variable nommée pointer (le symbole * n'est pas inclus dans cet identificateur) telle que :

• le type de cette variable est « pointeur d'entier standard » – son descripteur est int * (et là, le symbole * est bien inclus dans le descripteur) ;
• la valeur initiale de cette variable est l'adresse de la variable number.

À la suite de cette déclaration, tant que la variable pointer n'aura pas fait l'objet d'une autre affectation, l'expression *pointer (composée avec l'opérateur de déréférencement) prendra la valeur courante de la variable number (c'est‑à‑dire 5 pour le moment) et suivra les affectations ultérieures dont number pourrait faire l'objet. Ainsi, en codant plus loin :

  number = 0;
  printf("%d\n", *pointer);

on obtient lors de l'exécution l'affichage 0 (et non pas 5).

De plus, l'expression *pointer est une l‑value, donc si par exemple on code ensuite :

  *pointer = 3;
  printf("%d\n", number);

on obtient lors de l'exécution l'affichage 3 (et non pas 0) car la valeur de variable number a été modifiée par l'intermédiaire de pointer. Autrement dit, tant qu'aucune affectation ne vient changer la valeur initiale de pointer (c'est‑à‑dire l'adresse sur laquelle il pointe), l'expression *pointer permet d'accéder aux valeurs de la variable number, aussi bien en lecture qu'en écriture. Grossièrement, on peut donc dire qu'elle en constitue un alias – du moins temporairement…

Car si par la suite on code :

  int otherNumber = 10;
  pointer = &otherNumber;
  printf("%d\n", *pointer);

alors on obtient lors de l'exécution l'affichage 10 (et non pas 3). En effet, l'expression *pointer suit maintenant la valeur de la variable otherNumber et non plus celle de number. La valeur du pointeur pointer a changé !

De même, on peut changer la valeur d'un pointeur, c'est‑à dire l'adresse de la donnée qu'il pointe, en lui affectant celle d'un autre pointeur déjà déclaré, par exemple :

  int * otherPointer = &number;
  pointer = otherPointer;

de sorte que maintenant, le pointeur de donnée pointer pointe à nouveau sur la variable number.

En conclusion, on voit qu'un pointeur de donnée déclaré n'est pas définitivement l'alias de la donnée sur laquelle il pointe lors de son éventuelle initialisation. C'est donc un outil très polyvalent et on verra qu'il est particulièrement commode pour accéder aux différents champs d'une donnée structurée (tableau, chaîne de caractère, etc.).

Syntaxiquement, les quatre déclarations ci‑dessous sont équivalentes :

1. int * p = &a;
2. int* p  = &a;
3. int *p  = &a;
4. int*p   = &a;

mais en termes de lisibilité et de robustesse, le format nº 1 est à privilégier.

Le descripteur unsigned int * code un type de pointeur sur des entiers standards non signés.

Le code ci‑dessous déclare le type P_uint comme synonyme de unsigned int *.

typedef unsigned int * P_uint;

L'identificateur P_uint peut ensuite être directement employé comme descripteur de type pour déclarer des pointeurs d'entiers non signés.

unsigned int a = 5, b = 3;
P_uint p = &a, q = &b;

Expérimentons justement l'incrémentation d'un pointeur sur des données hétérogènes avec le programme Arduino ci‑dessous :

uint8_t   a = 8;
uint8_t * p = &a;
uint16_t  b = 256;

void setup()
{
  Serial.begin(115200);
  Serial.println("Address Value");

  Serial.print(int(&a), HEX); Serial.print("\t"); 
  Serial.println(a);

  Serial.print(int(&b), HEX); Serial.print("\t"); 
  Serial.println(b);

  p += 3;             // TEST POINTER INCREMENTATION
  Serial.print(int(p), HEX);  Serial.print("\t"); 
  Serial.println(*p);
}

void loop() {}

Simulé dans l'environnement Tinkercad, il affiche dans la fenêtre du moniteur série la sortie suivante :

Address Value
100     8
103     256
103     0

Après exécution de l'incrémentation p += 3 (ligne nº 16), l'expression *p prend la valeur 0 car à l'adresse 0x103 se trouve l'octet de poids faible du mot de 16 bits qui encode en binaire naturel l'entier 256 (la valeur de la variable b). En effet, en binaire naturel sur deux octets, cette valeur est encodée :
0000 0001  0000 0000
donc :

• 0000 0000 sur l'octet d'adresse 0x103,
• 0000 0001 sur l'octet d'adresse 0x104.

Après incrémentation, le déréférencement de p ne correspond donc pas à une donnée stockée, mais seulement une partie d'une donnée stockée à l'adresse pointée !

Considérons le programme académique Arduino ci‑dessous, qui déclare deux pointeurs d'entiers standards p et q :

int a = 5, b = 3;
int * p = &a, * q = &b;

void setup()
{
  Serial.begin(115200);
  Serial.println(p < q);
}
void loop() {}

Lors de l'exécution sur une carte Uno, l'évaluation de l'expression p < q (ligne nº 7) donne la valeur affichée suivante :

0 avec Arduino IDE, car l'attribution des adresses aux données procède dans l'ordre inverse de leurs déclarations respectives (a obtient l'adresse 0x102 et b l'adresse 0x100) ;

1 en simulation sous Tinkercad, car l'attribution des adresses aux données procède dans l'ordre direct de leurs déclarations respectives (a obtient l'adresse 0x100 et b l'adresse 0x102).

Rappelons que la fonction printf (cf. chap. C2‑VII ) permet, en hexadécimal, d'afficher l'encodage d'une donnée de type int : il suffit d'utiliser la spécification de conversion %X, comme dans le programme ci‑dessous.

#include <stdio.h>

int main(void)
{
  int a = -1;
  printf("%d is encoded %X", a, a);
  return 0;
}

Ainsi, avec l'environnement de compilation en ligne OnlineGDB, on obtient l'affichage attendu :

-1 is encoded FFFFFFFF

En effet, en complément à 2, l'entier relatif -1 est bien encodé comme 1…1 sur 32 bits, soit FFFFFFFF en hexadécimal (cf. chap. C3‑II ).

Mais il n'est pas possible de procéder de même pour une donnée de type float (ou de tout autre type flottant). En effet, si on code :

#include <stdio.h>

int main(void)
{
  float a = 1.0;
  printf("%.1f is encoded %X", a, a); // does NOT work!
  return 0;
}

avec OnlineGDB, le compilateur émet un avertissement et on obtient une sortie incorrecte, typiquement :

main.c: In function ‘main’:
main.c:14:28: warning: format ‘%X’ expects argument of type ‘unsigned int’, but argument 3 has type ‘double’ [-Wformat=]
   14 |   printf("%.1f is encoded %X", a, a); // does NOT work!
      |                           ~^      ~
      |                            |      |
      |                            |      double
      |                            unsigned int
      |                           %f
1.0 is encoded B3500D48

Pour surmonter cet obstacle et afficher l'encodage d'une donnée de type float, il suffit de recourir à un pointeur d'entier non signé de même taille que la variable a, donc uint32_t (4 octets). Le code ci‑dessous implémente une telle solution :

#include <stdio.h>
#include <stdint.h>

float a = 1.0;
uint32_t * p = (uint32_t*) &a;

int main(void)
{
  printf("%.1f is encoded %X\n", a, *p);
}

et avec OnlineGDB, on obtient l'affichage attendu :

1.0 is encoded 3F800000

Et en effet, on peut aisément vérifier que la valeur hexadécimale 3F800000 est bien conforme à l'encodage binaire de la valeur 1.0 dans le type float (cf. chap. C3‑V ) par l'analyse détaillée comme celle de la figure ci‑dessous :

que l'on peut décoder en partant de la gauche :

• le bit de signe vaut s = 0 ;
• l'exposant décalé vaut q = 127 (0111 1111 en binaire) ;
• le significande vaut f = 0 ;

En définitive, on obtient bien  (−1)⁰ × (1 + 0,0) × 2^{127 − 127}  =  1 × 2⁰  =  1,0.

Procédons avec un exemple académique similaire à celui proposé pour illustrer la déclaration d'un pointeur (cf. exemple supra ) :

int number = 5;
int & refNumber = number;

À partir de la donnée number déclarée en ligne n° 6, la référence déclarée refNumber aura toujours la même valeur que son référent qui est number, et ce quelles que soient les affectations effectuées sur l'une ou l'autre. Par exemple, dans l'extrait de code ci‑dessous :

  number = 10; // refNumber = number = 10
  refNumber++; // refNumber = number = 11

la variable number est modifiée aussi bien par affectation directe ou par l'intermédiaire de son référent. Autrement dit, si on l'on code par la suite :

  int otherNumber = 7; 
  refNumber = otherNumber; 
  otherNumber = 2;

alors refNumber prend la valeur 7 mais pour autant, elle ne devient pas un alias de otherNumber. Car après exécution de l'instruction de la ligne nº 22 qui modifie la valeur de otherNumber, la référence refNumber ne vaut pas 2 mais encore 7.

Reprenons l'exemple classique ci‑dessous de la fonction swapInt qui permet de permuter les valeurs respectives de deux variables. Ici, elle est codée en langage C++ avec passage des arguments par référence (cf. la ligne nº 3) :

#include <cstdio>

void swapInt(int & a, int & b)
{ 
  int c = a;
  a = b;
  b = c;
}

int nb1 = 1, nb2 = 2;

int main(void)
{ 
  printf("BEFORE swap: nb1 = %d   nb2 = %d\n", nb1, nb2);
  swapInt(nb1, nb2);
  printf(" AFTER swap: nb1 = %d   nb2 = %d\n", nb1, nb2);
  return 0;
}

Compilé et exécuté sous OnlineGDB, ce programme produit la sortie ci‑dessous parfaitement conforme aux attentes :

BEFORE swap: nb1 = 1   nb2 = 2
 AFTER swap: nb1 = 2   nb2 = 1