Reprenons l'exemple académique de la fonction swapInt qui permute la valeur de deux variables, proposée pour illustrer la syntaxe du passage d'argument par référence en C++ (cf. chap. C5‑I ).

Rappelons que, codé de la façon suivante :

#include <stdio.h>

void swapInt(int a, int b) // warning: THIS DOES NOT WORK!
{
  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);
}

le programme de test de la fonction swapInt présente une exécution dysfonctionnelle (les variables nb1 et nb2 restent inchangées). En effet, lors de l'appel de la fonction swapInt (ligne n° 15), les valeurs des arguments effectifs nb1 et nb2 stockées dans le segment data sont affectées aux arguments formels a et b de la fonction, qui sont mémorisés temporairement dans la pile, un peu comme si le programme exécutait les instructions :

•  int a = nb1;
•  int b = nb2;

C'est donc dans la pile que la permutation des valeurs est opérée par la fonction, et non pas dans le segment data.

A contrario, en utilisant des pointeurs, le programme devient :

#include <stdio.h>

void swapInt(int * p, int * q)  // arguments are pointers
{  
  int c = *p;
  *p = *q;
  *q = 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;
}

Lors de l'appel de la fonction swapInt (ligne n° 15), comme ses arguments effectifs sont des adresses de variables, leur transmission aux arguments formels de la fonction vient compléter la déclaration de ces derniers :

•  int * p = &nb1;
•  int * q = &nb2;

Depuis la pile, les arguments formels p et q pointent alors respectivement sur arguments effectifs nb1 et nb2 dans le segment .data. C'est donc dans ce segment que la permutation des valeurs est opérée et ainsi, le programme devient effectif.

Si p_a est une donnée préalablement déclarée de type int* (pointeur d'entier standard) qui pointe sur une donnée a de type int, alors l'instruction :
int ** pp_a = &p_a;
déclare une variable pp_a qui pointe sur l'adresse de pa.

Remarque. On peut aussi coder cette déclaration :
int* * pp_a = &p_a;
afin de mieux visualiser le fait que les valeurs pointées par pp_a sont de type int*.

Si pp_a est un pointeur de pointeur déclaré comme supra, alors :

• l'expression *pp_a donne la valeur de p_a, c'est‑à‑dire l'adresse de a ;
• l'expression **pp_a donne la valeur de a.

Dans le code académique ci‑dessous :

  int sum(int a, int b) {return a + b;}
  int (*p_f) (int, int) = sum;

• on déclare d'abord la fonction sum qui retourne une valeur entière égale à l'addition des valeurs de ses deux arguments entiers ;
• puis on déclare p_f, un pointeur de fonction rendant une valeur entière et prenant deux arguments entiers, et on donne à ce pointeur la fonction sum comme valeur initiale.

Mais notons bien que le pointeur p_f pourrait pointer sur n'importe quelle autre fonction de même forme, c'est‑à‑dire prenant deux arguments entiers et rendant pour valeur un entier. Ainsi, on pourrait coder par la suite :

  int dif(int a, int b) {return a - b;}
  *p_f = dif;

En reprenant les déclarations de l'exemple académique précédent (lignes nº 10 & 11), l'instruction ci‑dessous :

  result = (*p_f) (2, 3);

affecte à une variable entière (déclarée préalablement) result la valeur rendue par la fonction pointée sum avec pour ses deux arguments effectifs respectivement les valeurs 2 et 3.

Au chapitre C2‑V , on avait déjà codé une version très rudimentaire de calculatrice arithmétique s'exécutant dans un terminal de commandes, dont l'élément central était une structure de bifurcation multiple switch pour déterminer l'opérateur saisi l'utilisateur sous forme d'un caractère (+ - * /).

  switch (oper) {
    case '+' : 
      printf("> %d\n", a + b);
    break;
    case '-' :  
      printf("> %d\n", a - b);
    break;
    case '*' :  
      printf("> %d\n", a * b);
    break;
    case '/' :  
      printf("> %d\n", a / b);
    break;
    default : 
      printf("Unknown operation!");
  }

L'inconvénient de cette solution est que les opérations de calcul (a + b, etc.) sont intégrées dans la bifurcation, alors que le rôle de cette dernière est simplement de déterminer l'opérateur, et non pas d'effectuer l'opération. Elle est donc malcommode à étendre à un grand nombre de fonctions comme on peut en trouver sur une véritable calculatrice.

Bien entendu, pour externaliser les calculs, on pourrait se contenter de remplacer ces expressions calculatoires par autant d'appels de fonctions, mais cela obligerait à effectuer à chaque fois un passage d'arguments. Là encore, une telle solution serait fastidieuse avec un grand nombre de cas.

C'est précisément là qu'apparaît l'intérêt des pointeurs de fonctions qui permet, pour chaque cas d'opérateur saisi par l'utilisateur, de renvoyer directement le pointeur de la fonction correspondante, sans aucun passage d'argument, comme on peut le voir dans la solution ci‑dessous :

#include <stdio.h>
#include <stdlib.h>

int sum(int a, int b) {return a + b;}
int dif(int a, int b) {return a - b;}
int mul(int a, int b) {return a * b;}
int dvd(int a, int b) {if (b != 0) return a / b; else exit(1);}

typedef int (* FunctionPointer)(int, int);

FunctionPointer functionMap(char operatorSymbol)
{
  switch (operatorSymbol) {
    case '+' : return sum;
    case '-' : return dif;
    case '*' : return mul;
    case '/' : return dvd;
    default  : exit(0);
  }
}


int main(void)
{
  char o;    // symbol of an arithmetic operator
  printf(" + - * / calculator / * - + \n");
  do {
    int a, b;  // operands
    printf("> ");
    scanf("%d %c %d", &a, &o, &b);
    printf("= %d\n", (*functionMap(o)) (a, b));
  }
  while (o == '+' || o == '-' || o == '*' || o == '/');
  return 0;
}

Ce programme est compilable et exécutable sur OnlineGDB. On obtient en sortie standard, conformément aux attentes, par exemple :

 + - * / calculator / * - + 
> 2 + 3
= 5
> 7 * 8
= 56
…

Considérons le programme académique ci‑dessous :

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
  int a = 5;
  float b = 0.1;
  void * p = &a;
  printf("a = %d\n", *((int*) p));   // displays 5
  p = &b;
  printf("b = %g\n", *((float*) p)); // displays 0.1
  return 0;
}

Après avoir déclaré deux variables a et b de types différents, on déclare le pointeur générique p et on lui affecte l'adresse de l'entier standard a (cf. la ligne nº 8). Ensuite :

• on peut obtenir la valeur de a par déréférencement de p, mais seulement après une conversion explicite dans le type int* (cf. la ligne nº 9) ;
• puis on peut affecter à p l'adresse de b et obtenir sa valeur, par déréférencement de p, mais seulement après une conversion explicite dans le type float* (cf. la ligne nº 11) ;

Ici, un seul et même pointeur suffit pour manipuler des données de types différents.

De façon très générale, après la déclaration :
 int * p = NULL;
on peut coder une bifurcation de la forme :
 if (p != NULL) …
pour tester si, entre‑temps, le pointeur p a fait ou non l'objet d'une nouvelle affectation.