En C, un objet est essentiellement une variable mémoire (par opposition à registre ou constante), modifiable ou non, mais munie d'une adresse.

Un pointeur sur objet (aussi appelé communément 'pointeur') est une variable qui peut contenir l'adresse d'un objet.

Pour définir un pointeur, on utilise un type, puis le signe '*' et enfin l'identificateur, suivit de ';' si on ne désire pas l'initialiser à la déclaration (peu recommandé). Sinon, on utilise l'opérateur '=', suivit de la valeur d'initialisation. Si le pointeur est déclaré dans un bloc, on peut utiliser la valeur retournée par une fonction.

 /* Definition d'un pointeur sur int */
   int *p_int;

Pour initialiser un pointeur, on peut soit :

• lui donner la valeur 0 ou NULL, qui signifie "invalide, ne pas utiliser".
• lui donner l'adresse d'une variable,
• lui donner la valeur retournée par les fonctions malloc(), realloc(), calloc().
• s'il est de type void ou FILE, lui donner la valeur retournée par fopen().
• s'il est de même type, ou void, lui donner la valeur d'un autre pointeur réputé correctement initialisé.

Pour accéder à la valeur pointée, le pointeur doit être typé (donc différent de void). Dans ce cas, on peut obtenir la valeur en utilisant l'opérateur de déréférencement '*'.

   /* Definition de la variable 'a' valant 4 */
   int a = 4;
 
   /* Definition d'un pointeur 'p' initialise' avec l'adresse de la variable 'a' */
   int *p = &a;
 
   /* Definition de la variable 'b' non initialisee */
   int b;
 
   /* recuperation de la valeur de 'a' dans 'b' via le pointeur 'p' */
   b = *p;
 
   /* 'b' vaut maintenant 4 */

Une fonction a une adresse qui est le nom de cette fonction. Un pointeur de fonction peut recevoir cette adresse. Il est possible, via un pointeur de fonction correctement initialisé, d'appeler une fonction.

Cette capacité du langage C lui confère une puissance rarement égalée, qui permet d'écrire du code flexible, dont les adresses des fonctions peuvent être définies à l'exécution. Cela permet de 'personnaliser' des fonctions génériques selon les besoins.

La définition des pointeurs de fonctions est un peu complexe, et a tendance à alourdir le code :

   /* pointeur sur une fonction avec 2 parametres */
   int (*pf) (int, char **);
 
   /* prototype d'un fonction ayant un pointeur de fonction comme parametre */
   int fun (int (*pf) (int, char **));

Si on doit manipuler des fonctions qui retournent un pointeur de fonction, ou des tableaux de pointeurs de fonction, le code devient rapidement illisible. C'est pourquoi il est fortement conseillé, et ce dans tous les cas, d'utiliser un typedef pour créer un alias sur le type de la fonction.

   /* definition d'un alias */
   typedef int fun_f (int, char **);
 
   /* definition d'un pointeur de fonction de ce type */
   fun_f *pf;
 
   /* prototype d'une fonction ayant un pointeur de fonction comme parametre */
   int fun (fun_f *pf);
 
   /* tableau de pointeurs de fonction */
   fun_f *pf[10];
 
   /* prototype d'une fonction retournant un pointeur de fonction */
   fun_f *getfunc (int);

La lecture et la maintenance du code s'en trouvent considérablement allégées.

Pour initialiser un pointeur de fonction, on peut soit :

• lui donner la valeur 0 ou NULL, qui signifie "invalide, ne pas utiliser".
• lui donner l'adresse d'une fonction.
• s'il est de même type, lui donner la valeur d'un autre pointeur réputé correctement initialisé.

Pour utiliser le pointeur, il suffit de l'invoquer comme une fonction.

   /* definition d'un alias */
   typedef int fun_f (int);
 
   /* definition d'un pointeur de fonction de ce type */
   fun_f *pf;
 
   /* prototype d'une fonction du meme type */
   int function (int);
 
   /* NOTA : on peut aussi utiliser le type */
   fun_f function;
 
   /* initialisation du pointeur de fonction */
   pf = fonction;
 
   /* appel de la fonction via le pointeur de fonction */
   pf (123);

XXI-B-2-a. Remarques importantes▲

Un paramètre de fonction est une variable locale de la fonction dont la valeur est donnée par l'appelant. Si on modifie cette valeur, on ne fait que modifier une variable locale. Exemple :

{
   int x = 123;
   f (x);
}

avec

void f (int a)
{
   a++;
}

Déroulement des opérations :

• x prend la valeur 123
• appel de la fonction f() avec en paramètre la valeur de x (soit 123)
• Dans f(), la variable locale a prend la valeur 123
• la valeur de a est augmentée de 1 et devient 124
• la fonction se termine
• la valeur de x n'a pas changé, elle vaut toujours 123.

Si on avait voulu modifier x en appelant f(), c'est raté.

Tout simplement en donnant un moyen à la fonction qui lui permettre de modifier la variable x. Ce moyen est simple. Il suffit de lui donner l'adresse de x et elle pourra alors modifier x gràce à un pointeur et à l'opérateur de déréférencement (*).

En fait, on va faire ceci :

{
   int x = 123;
   int *p = &x;
   (*p)++;
}

C'est à dire

• x prend la valeur 123
• p prend l'adresse de x
• x est incrémenté via p et l'opérateur de déréférencement. Il vaut maintenant 124.

sauf que les opérations vont être réparties entre l'appelant et l'appelé comme ceci :

{
   int x = 123;
   f (&x);
}

avec

void f (int *p)
{
   (*p)++;
}

• x prend la valeur 123
• l'adresse de x est passée à la fonction
• dans f(), la variable locale p est initialisée avec l'adresse de x
• la valeur de x est incrémentée de 1 via p et l'opérateur de déréférencement. Elle vaut maintenant 124.
• la fonction se termine
• la valeur de x a changé, elle vaut maintenant 124.

Voilà donc un exemple d'utilisation des pointeurs. Pour un tableau, par exemple, il n'y a pas le choix. La seule façon de faire est de passer l'adresse du premier élément du tableau via un pointeur sur le même type que l'élément.

Ensuite, on a accès à tous les éléments du tableau. Non seulement le [0] en *p , mais aussi aux autres, grâce aux propriétés de l'arithmétique des pointeurs.

En effet, le type étant connu, l'adresse des autres éléments est tout simplement p+1, p+2 etc.

L'élément lui même se trouve donc en *(p + 1), *(p + 2) etc. Le langage C définit cette écriture comme strictement équivalente à p[1], p[2] etc. On dit alors que la 'notation tableau' peut s'appliquer aux pointeurs. Mais cela ne signifie pas qu'un pointeur soit un tableau ni inversement comme on le lit parfois.

Ce principe est massivement utilisé avec les chaines de caractères, qui, rappelons le, sont des tableaux de char initialisés avec des valeurs de caractères et terminés par un 0.

Il est rare de nos jours d'utiliser un compilateur datant d'avant la normalisation du langage C (1989 aux USA, 1990 au niveau international). En effet, ces compilateurs ne supportent pas les prototypes, ce qui les rend impropre à produire du code cohérent, à moins d'utiliser un outil de vérification indépendant comme PCLint.

Le cas peut cependant se produire, s'il s'agit de maintenir du code ancien avec une chaine de compilation ancienne. Dans ce cas, effectivement, le cast est indispensable si le type du pointeur et différent de char*.

L'opportunité de conserver une telle pratique est donc laissée à l'appréciation du programmeur. Il semble cependant assez évident que dans les nouveaux développements utilisant un compilateur ISO, il est inutile d'ajouter le cast.

Il est techniquement possible, à de rares exceptions syntaxiques près, de faire compiler du code C par un compilateur C++. Néanmoins, cette pratique est rarement justifiée et est largement déconseillée.

En effet, en dehors des points syntaxiques évidents (comme par exemple la conversion de type explicite void* <-> type* qui justement oblige à utiliser le cast) plusieurs points de sémantique diffèrent entre les deux langages. En l'état actuel des normes, les spécifications C++98 et C99 ont même plutôt tendance à diverger (cette situation pourrait changer en 2005 avec une nouvelle révision de C++ intégrant les nouveautés de C99).

On peut aussi se demander pourquoi on utiliserait malloc() et free() en C++, alors que ce langage dispose des opérateurs new et delete . D'autre part, en C++98, un cast se fait avec static_cast<...>.

Lire à ce sujet : Incompatibilities Between ISO C and ISO C++