La généricité en langage C

Vous avez sûrement déjà rencontré le pointeur générique, notamment lors d'allocations mémoire. En effet, la fonction malloc a pour signature :

void * malloc( size_t size)

La fonction renvoie un pointeur générique. Ceci est tout à fait normal puisque la fonction ne sait pas quel doit être le type de retour, ce qui lui importe, c'est la taille à allouer. Ne connaissant pas la taille du type à allouer, elle doit donc renvoyer un pointeur vers n'importe quel type d'objet, il s'agit donc du pointeur générique. Comme le pointeur est générique, il doit pouvoir être affecté sans problème. De plus, on doit pouvoir lui affecter un pointeur sur un type donné. L'exemple suivant montre l'utilisation possible d'un pointeur générique pour afficher l'adresse d'une variable :

#include <stdio.h>
#include <stdlib.h>
int main ( void )
{
void * ptr = NULL;
int a = 2;
ptr = &a;
printf("%p\n",ptr);
return EXIT_SUCCESS;
}

Ici, le pointeur générique remplace donc un pointeur sur un entier.

Supposons que nous voulions une fonction qui échange deux éléments quels qu'en soient leurs types (il faut au moins que les deux élements soient du même type). A première vue, nous pourrions penser à une fonction utilisant des pointeurs génériques comme ceci :

void swap( void * a , void * b)
{
	void * tmp;
	tmp = a;
	a = b;
	b = tmp;
}

Supposons que nous effectuons le petit test suivant :

int a = 3;
int b = 2;
swap( &a, &b );
printf( "a = %d , b = %d" , a , b );

Nous aurions en sortie ceci :

a = 3 , b = 2

Ceci est tout à fait prévisible et nous avons été un peu vite en besogne pour l'écriture de notre fonction d'échange. En effet, il faut toujours avoir à l'esprit que la langage C effectue ce qu'on appelle du passage par copie. Ceci signifie donc que les arguments que l'on passe à une fonction sont copiés. Ainsi, pour notre fonction, ce ne sont pas les variables a et b que nous échangeons mais leur copie. Si vous avez déjà effectué une fonction qui doit échanger deux entiers, vous avez sûrement procédé ainsi :

void swap_int( int * a, int * b)
{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

Pourquoi ne pas faire la même chose avec notre fonction d'échange générique ? Et bien parce que nous ne le pouvons pas ! En effet, si nous échangeons vulgairement le type int par le type void, nous allons nous retrouver avec cette écriture :

void tmp = *a;

Or comme nous l'avons dit plus tôt, le type void ne permet pas de stocker quoi que se soit. De plus, l'opération de déréférencement de a provoquerait aussi une erreur. En effet, il n'est pas possible de déréférencer un pointeur générique. Ceci s'explique aussi par le fait que le pointeur générique ne sait pas vers quel type de variable son contenu pointe. Par conséquent, le déréférencer voudrait dire que l'on aurait une variable dont l'espace de stockage ne serait pas défini. Pour résoudre nos problèmes (passage par valeur et déréférencement impossible), il faut ruser et passer par un niveau de pointeur supérieur. Ainsi notre fonction d'échange correcte est celle ci :

void swap( void * d1 , void * d2 )
{
	void * tmp;
	tmp = *(void **)d1;
	*(void **)d1 = *(void **)d2;
	*(void **)d2 = tmp;
}

La fonction réalise un échange de pointeurs, d1 pointe vers ce qui était pointé par d2 et d2 pointe vers ce qui était pointé par d1. Cependant, cela ne résoud toujours pas notre problème. En effet nous n'échangeons que des pointeurs et pas le contenu des variables. Afin d'échanger correctement le contenu des variables, il faut concrètement copier l'espace mémoire qui se situe aux adresses données. Or comme les pointeurs génériques ne connaissent pas la taille occupée en mémoire des objets vers lesquels il pointe, il faut explicitement passer cette taille en paramètre de notre fonction d'échange. Finalement notre fonction d'échange générique est la suivante:

int swap (void *const a, void *const b, size_t size)
{
   void *const temp = malloc(size);

   if ( temp == NULL )
     return EXIT_FAILURE;
   
   memcpy(temp, a, size);
   memcpy(a, b, size);
   memcpy(b, temp, size);

   free(temp);

  return EXIT_SUCCESS;
}

Cette fonction va renvoyer la constante EXIT_SUCCESS si l'échange a pu avoir lieu, sinon, elle va renvoyer EXIT_FAILURE.

Il existe aussi un autre problème liée au pointeur générique, en effet, comme il est générique, il ne connaît pas l'espace mémoire des objets vers lesquels il pointe. Ceci entraîne donc un déréférencement impossible mais aussi des calculs d'adresses impossibles. Il ne sera donc pas possible d'effectuer des opérations de ce genre :

void * ptr;
/* ... On initialise ptr ... */
printf("%p", ptr + 1);

On ne peut pas le faire encore une fois parce que le pointeur générique ne connaît rien de ce vers quoi il pointe, y compris l'espace mémoire de la variable vers laquelle il pointe.