utiliser qsort avec void**

Version imprimable

Bonjour,

D' ou vient l' erreur :

Code:

1
2
3
4
5
6
 
void ** data =  ( les donées par ex. ) .
nb = 10 ; // par ex.
siz = sizeof( la structure ) ;
fcmp = fonction de comparaison ;
qsort( (void*) data, nb, siz, fcmp ) ;

ça plante. Comment y arriver ?

salut

Bonsoir

Il me semble qu'il te manque des chose non ??
Code:

1 2 3 qsort (void *??, nb, size, (*compar)(const void *, const void *));

02/02/2007, 02h12
dj.motte

Bonjour,

Non data est de type void** et la fonction de comparaison est correcte.
En dans fait le prototype de qsort le tableau doit être de type void* alors que j' essaie avec un tableau de type void** . C' est ce qui bloque.
02/02/2007, 07h14
Thierry Chappuis
Bonjour,

La doc est le meilleur moyen d'en avoir le coeur net:
Code:

1 2 3 4 5 #include <stdlib.h> void qsort (void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
Voir: http://man.developpez.com/man3/qsort.3.php

Le 1er paramètre de qvoid est donc de type void*. Lorsque tu as des doutes, la documentation est ton amie. Pas de programmation au hasard!

Meilleures salutations

Thierry
02/02/2007, 07h18
spawntux

Ok lol c'est donc ce que je disait enfin dans les grande ligne mdr ^^^^:roll:
02/02/2007, 11h19
Emmanuel Delahaye
Citation:
Envoyé par dj.motte

Bonjour,

D' ou vient l' erreur :

Code:

1 2 3 4 5 6 void ** data = ( les donées par ex. ) . nb = 10 ; // par ex. siz = sizeof( la structure ) ; fcmp = fonction de comparaison ; qsort( (void*) data, nb, siz, fcmp ) ;

ça plante. Comment y arriver ?
data pointe visiblement sur un tableau de pointeurs sur void. C'est voulu ? Pourquoi pas un tableau de structures, ce serait plus clair. Admettons.

Ensuite, il faut bien comprendre ce que fait qsort(). Il trie les éléments du tableau. Pour ça, il doit connaitre :
- l'adresse du début du tableau : data
- la taille d'un élément : sizeof *data
- le nombre d'élements : 10
Ca s'appelle comme ça :

Code:

qsort (data, 10, sizeof *data, fcmp);

ensuite, il faut savoir que les paramètres de la fonction de comparaison vont recevoir l'adresse de 2 éléments du tableau.

Leur type réel est bien sur 'adresse de pointeur sur void', soit void **. Il faut donc être bien réveillé en codant la fonction de comparaison...

Si on veut accéder aux éléments, il va falloir récupérer l'adresse, puis initialiser un pointeur du bon type...

qsort(), c'est puissant mais il faut réfléchir et bien savoir ce qu'on fait. Plus que jamais, "le C n'est pas un langage de débutant en informatique".
02/02/2007, 16h58
dj.motte

Bonjour,

Citation:

data pointe visiblement sur un tableau de pointeurs sur void. C'est voulu ? Pourquoi pas un tableau de structures, ce serait plus clair. Admettons.

Effectivement c' est voulu, data est dans mon cas de type void ** .
La question est :
Puis-je me servir de qsort avec un tabeau de type void** alors que le prototype de qsort attend un tableau de type void *.

J' ai essayé, sans résultat. A mon avis ce n' est pas possible. A moins que ...

salut.
02/02/2007, 18h05
diogene

Tu veux trier les pointeurs ? en lui faisant croire que la taille de tes pointeurs est égale à la taille de ta structure ?

Comme c'est bizarre!

Bonjour,

Est-il possible de trier g_data avec qsort dans cette structure ?

Code:

1
2
3
4
5
6
 
typedef struct mvect
 { void ** g_data ;
   size_t  g_size ;
   size_t  g_cnt ;
 } mvect ;

Je ne pense pas. J' ai donc réimplémenté un tri comme :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 void mvect_qsort( mvect *V , int g, int d, int (*F)(const void*, const void*) )
 { void *  tmp ;
   void * tp ;
   int lo = g ;
   int hi = d ;
   int p = ( lo + hi ) / 2 ;
   tmp = V->g_data[p]   ;
 
   do
   { while( F( V->g_data[lo], tmp ) < 0 ) lo++;
     while( F( V->g_data[hi], tmp ) > 0 ) hi--;
 
     if( lo <= hi )
     { tp = V->g_data[lo]  ;
       V->g_data[lo] = V->g_data[hi] ;
       V->g_data[hi] = tp  ;
       lo++;
       hi--;
     }
    } while( lo <= hi ) ;
   if( hi > g ) mvect_qsort( V,g, hi, F);
   if( lo < d ) mvect_qsort(V ,lo,d, F ) ;
 }

Ca a l' air de fonctionner

salut

02/02/2007, 19h10
Emmanuel Delahaye

Citation:

Envoyé par dj.motte

Puis-je me servir de qsort avec un tabeau de type void** alors que le prototype de qsort attend un tableau de type void *.

J' ai essayé, sans résultat. A mon avis ce n' est pas possible. A moins que ...

Bien sûr que c'est possible. Je t'ai indiqué comment faire. La difficulté est d'écrire la bonne fonction de comparaison.

Mais en l'absence d'autres informations sur les données (void *, c'est un peu léger), on ne peut que trier les pointeurs que sur leur valeur, ce qui n'est pas d'un intérêt capital.

Montre ton code compilable.
02/02/2007, 19h24
diogene

Je suppose que g_data est un tableau de pointeur sur les éléments X à trier. Le tri se fera par échange de position des pointeurs dans le tableau. Donc la dimension à donner à qsort est la dimension d'un pointeur sur X. Par contre, la fonction de comparaison recevra l'adresse des pointeurs sur X en argument et pourra retrouver ainsi la valeur des pointeurs puis des elements X. Ce sont ces derniers qu'il faut comparer pour retourner la bonne valeur.

Salut,

Effectivement g_data est un tableau à trier d' éléments à longueur fixe.
Mais le problème vient peut-être de la fonction de comparaison.

Soit la structure :
Code:

1 2 3 4 5 6 7 typedef struct TR { int i ; float f ; double d ; char z[20] ; } TR ;
Répliquées 20 fois dans le g_data de :
Code:

1 2 3 4 5 6 7 typedef struct mvect { void ** g_data ; // ici le tableau de TR size_t g_siz ; size_t g_cnt ; int g_ref ; } mvect ;
Les fonctions de comparaison essayées :
Code:

1 2 3 4 5 6 7 8 typedef int (*__fcmp)( const void *, const void * ) ; int cmpTr( const TR * e1, const TR * e2 ) { return strcmp( e1->z , e2->z ) ; } int cmpVd( const void * e1, const void * e2 ) { return strcmp( ((TR*)e1)->z , ((TR*)e2)->z ) ; }
ne donnent rien avec la syntaxe suivante :
Code:

1 2 3 4 5 6 soit V un mvect * , rempli de 20 TR ... soit V->g_cnt le nombre d' éléments dans V->g_data ( 20 par ex.) qsort( V->g_data , V->g_cnt , sizeof( TR ) , (__fcmp) cmpVd ) ; // raté qsort( V->g_data , V->g_cnt , sizeof( TR* ) , (__fcmp) cmpVd ) ; // raté etc...
Ca ne donne rien. Une idée peut-être ? Je planche et plus je cherche plus je rajoute des erreurs...bref. Peut-être la fonction de comparaison n' est pas au point ?

Citation:

Ca ne donne rien. Une idée peut-être ? Je planche et plus je cherche plus je rajoute des erreurs...bref. Peut-être la fonction de comparaison n' est pas au point ?

Eh oui... Lit la doc de qsort ...

1) Les paamètres de la fonction de tri doivent être void *
2) La fonction doit retourner 1, -1, ou 0...

strcmp ne retourne pas 1, -1, ou 0....

Donc :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 int cmpTr( const void *te1, const void *te2 ) { TR *e1 = (TR *)te1 ; TR *e2 = (TR*)te2 ; int i ; i = strcmp ( e1->z , e2->z ) ; if ( i > 0 ) return 1 ; else if ( i < 0 ) return -1 ; else return 0 ; }
Déjà ça..

Pour le reste, j'avoue ne pas trop comprendre ce que tu cherches à faire...

03/02/2007, 10h48
Emmanuel Delahaye

1 pièce(s) jointe(s)
Citation:

Envoyé par souviron34

Eh oui... Lit la doc de qsort ...

Bonne idée, que tu devrais aussi appliquer...

Citation:

1) Les paramètres de la fonction de tri doivent être void *

Non. Ils doivent être de type void const *.

Citation:

2) La fonction doit retourner 1, -1, ou 0...
strcmp ne retourne pas 1, -1, ou 0....

strcmp() est fait pour retourner exactement ce que doit retourner la fonction de comparaison de qsort(). Il n'y a rien à modifier.
Citation:
Code:

1 2 3 4 5 int cmpTr( const void *te1, const void *te2 ) { TR *e1 = (TR *)te1 ; TR *e2 = (TR*)te2 ;
Si tu avais lu correctement la doc de qsort(), tu aurais lu que les adresses te1 et te2 (drôles de nom...) sont celles des éléments du tableau. Or ici, on a un tableau de pointeur. Ce sont dont des adresses de pointeurs.
Code:

1 2 3 4 int cmp (void const *pa, void const *pb) { TR const *const *ppa = pa; TR const *const *ppb = pb;
Pour récupérer l'adresse des structures, il faut déréférencer ces pointeurs :
Code:

1 2 3 TR const *e1 = *ppa; TR const *e2 = *ppb;
maintenant, on peut accéder aux éléments :
Code:

1 2 3 return strcmp ( e1->z , e2->z ); }
Affaire reglée.
03/02/2007, 11h17
Emmanuel Delahaye
Citation:

Envoyé par dj.motte

Effectivement g_data est un tableau à trier d' éléments à longueur fixe.

Un tableau, quoi.
Citation:
Soit la structure :

Code:

1 2 3 4 5 6 7 typedef struct TR { int i ; float f ; double d ; char z[20] ; } TR ;

Répliquées 20 fois dans le g_data de :

Code:

1 2 3 typedef struct mvect { void ** g_data ; // ici le tableau de TR
Je ne vois pas pourquoi il faut un void ** pour stocker l'adresse d'un tableau...

C'est TR * (ou void * pour être générique), c'est tout.

Je rappelle que le principe :

1 - On définit un type T pour un élément de tableau
2 - On définit un tableau de n x T
2.1 - soit statiquement :

Code:

T a[n];

2.2 - soit dynamiquement :

Code:

T *pa = malloc (sizeof *pa * n);

3 - pa est un pointeur sur T qui contient l'adresse du premier élément du tableau. Il est donc, en toute logique, de type T *.
03/02/2007, 16h30
dj.motte

Bonjour,

Citation:

Je ne vois pas pourquoi il faut un void ** pour stocker l'adresse d'un tableau...

C'est TR * (ou void * pour être générique), c'est tout.

Effectivement le but de mvect est d' être générique. J' ai choisi un type void** parce que je trouve que l' accés indicé me paraît plus simple, que le calcul Pos * sizeof( T ) . En fait comme le dit Emmanuel un simple void * peut suffire, dans ce cas, et facilite l' utilisation de qsort.

salut

Bonjour,

Merçi pour l' exemple .
La question était bien dans la fonction de comparaison.
Peut-on remplacer :

Code:

1
2
3
4
5
6
7
8
 
int cmp (void const *pa, void const *pb)
 { TR const *const *ppa = pa;
   TR const *const *ppb = pb;
   TR const *e1 = *ppa;
   TR const *e2 = *ppb;
   return strcmp (e1->z, e2->z);
 }

par

Code:

1
2
3
4
5
6
7
8
 
int cmp1 ( const void *pa, const void  *pb)
 { TR ** ppa = (TR**) pa;
   TR ** ppb = (TR**) pb;
   TR  *e1 = *ppa;
   TR  *e2 = *ppb;
   return strcmp (e1->z, e2->z);
 }

salut

03/02/2007, 17h16
Médinoc

NON : Perte de const-correctness, inutile qui plus est.
03/02/2007, 17h32
dj.motte
Bonjour,

D' accord pas de changement pour cmp.
Maintenant dans
Code:

1 2 3 4 5 void tri (TR ** q, size_t n) { qsort (q, n, sizeof *q, cmp); }
j' ai l' impression que sizeof * q sera toujours égal à 4, avec un processeur 32 bits.

salut
03/02/2007, 17h34
Médinoc

Évidemment : Tu passes un tableau de pointeurs à qsort, ce seront donc les pointeurs qui seront triés selon la chaîne z de l'objet sur lequel chacun pointe : Les objets pointés, eux, resteront où qu'ils soient.
03/02/2007, 18h11
Emmanuel Delahaye
Citation:
Envoyé par dj.motte

Bonjour,

D' accord pas de changement pour cmp.
Maintenant dans

Code:

1 2 3 4 5 void tri (TR ** q, size_t n) { qsort (q, n, sizeof *q, cmp); }

j' ai l' impression que sizeof * q sera toujours égal à 4, avec un processeur 32 bits.
Peut être, c'est grave ? Ceci est destiné à trier un tableau de pointeurs (c'est toi qui a lancé l'idée du void **, alors moi, bête et discipliné, je respecte la consigne).

Si tu veux trier un tableau de structures, tu fais ;
Code:

1 2 3 4 5 void tri (TR * q, size_t n) { qsort (q, n, sizeof *q, cmp); }
et voilà. C'était pas trop dur comme maintenance...

Remarque, plus l'objet est petit, plus le tri est rapide... Un tableau de pointeurs sur des structures est donc plus rapide à trier qu'un tableau de grosse structure.

Bonjour,

Cela pourait être plus complexe avec :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
 
//#include <stdlib.h>
#include <stdio.h>
 
int Array[] = { 100, -4, 11 ,99,-9,5,78,90,37,71,1,54,31,-2, -1 ,123,-9,7,36,198,11,98,67,38,12,7,23,78,89,32,2 };
unsigned  max = sizeof( Array ) / sizeof( Array[0] ) ;
 
 int intcomp( int *c1, int *c2 )
    { return( *c1 - *c2 ) ; }
 
typedef int comparF (const void *, const void *);
 
static  comparF    *Fcmp;
static  unsigned    qWidth;
#define _LT_(x,y)       (x < y)
 
/*-----------------------------------------------------------------------*
Name            Exchange - exchanges two objects
Usage           static  void  Exchange (void  *leftP, void *rightP);
Description     exchanges the qWidth byte wide objects pointed to
		by leftP and rightP.
Return value    Nothing
*------------------------------------------------------------------------*/
 
 void  Exchange (void  *leftP, void *rightP)
  { unsigned  i;
    char  c;
    char *lp = (char *)leftP;
    char *rp = (char *)rightP;
 
    for (i = 0; i < qWidth; i++ )
     { c = *rp;
       *rp++ = *lp;
       *lp++ = c;
     }
  }
 
/*-----------------------------------------------------------------------*
Background
 
The Quicker Sort algorithm was first described by C.A.R.Hoare in the
Computer Journal, No. 5 (1962), pp.10..15, and in addition is frequently
described in computing literature, notably in D. Knuth's Sorting and
Searching.  The method used here includes a number of refinements:
 
- The median-of-three technique described by Singleton (Communications
  of the A.C.M., No 12 (1969) pp 185..187) is used, where the median
  operation is also the special case sort for 3 elements.  This slightly
  improves the average speed, especially when comparisons are slower
  than exchanges, but more importantly it prevents worst-case behavior
  on partly sorted files.  If a simplistic quicker-sort is run on a file
  which is only slightly disordered (a common need in some applications)
  then it is as slow as a bubble-sort.  The median technique prevents
  this.
 
  Another serious problem with the plain algorithm is that worst-case
  behavior causes very deep recursion (almost one level per table
  element !), so again it is best to use the median technique.
 
- The values of width and compar are copied to static storage and a help
  function with a minimum of parameters is used to reduce the recursion
  overheads.  Recursion is used both for simplicity and because there
  is no practical gain from conversion to loops: the extra housekeeping
  needed for loops needs registers for speed, but the 8086 family has not
  enough registers.  Juggling registers takes just as much time as calling
  subroutines.
 
/************************************************************************/
Name            qSortHelp - performs the quicker sort
Usage           static void  near pascal  qSortHelp (char *pivotP,
						     size_t nElem);
Description     performs the quicker sort on the nElem element array
		pointed to by pivotP.
Return value    Nothing
*------------------------------------------------------------------------*/
 
void  qSortHelp (char *pivotP, size_t nElem)
{   char     *leftP, *rightP, *pivotEnd, *pivotTemp, *leftTemp;
    unsigned  lNum;
    int       retval;
 
tailRecursion:
    if (nElem <= 2)
     { if (nElem == 2)
	{ if (Fcmp (pivotP, rightP = qWidth + pivotP) > 0)
	  Exchange (pivotP, rightP);
	}
      return;
     }
 
    rightP = (nElem - 1) * qWidth + pivotP;
    leftP  = (nElem >> 1) * qWidth + pivotP;
    //leftP  = (nElem / 2 ) * qWidth + pivotP;
 
/*  sort the pivot, left, and right elements for "median of 3" */
 
    if (Fcmp (leftP, rightP) > 0)
	Exchange (leftP, rightP);
    if (Fcmp (leftP, pivotP) > 0)
	Exchange (leftP, pivotP);
    else if (Fcmp (pivotP, rightP) > 0)
	Exchange (pivotP, rightP);
 
    if (nElem == 3)
       { Exchange (pivotP, leftP);
	 return;
       }
 
/*  now for the classic Hoare algorithm */
 
    leftP = pivotEnd = pivotP + qWidth;
 
    do {
	while( (retval = Fcmp(leftP, pivotP)) <= 0)
	 { if (retval == 0)
	   { Exchange(leftP, pivotEnd);
	     pivotEnd += qWidth;
	   }
	   if (_LT_ (leftP, rightP)) leftP += qWidth;
	   else goto qBreak;
	 }
	while (_LT_(leftP, rightP))
	 {  if ((retval = Fcmp(pivotP, rightP)) < 0)
	    rightP -= qWidth;
	    else
	    { Exchange (leftP, rightP);
	      if (retval != 0)
	       { leftP += qWidth;
		 rightP -= qWidth;
	       }
	     break;
	    }
	 }
       } while (_LT_(leftP, rightP));
 
 qBreak:
 
    if (Fcmp(leftP, pivotP) <= 0)
	leftP = leftP + qWidth;
 
    leftTemp = leftP - qWidth;
    pivotTemp = pivotP;
    while ((pivotTemp < pivotEnd) && (leftTemp >= pivotEnd))
     { Exchange(pivotTemp, leftTemp);
       pivotTemp += qWidth;
       leftTemp -= qWidth;
     }
 
    lNum = (leftP - pivotEnd) / qWidth;
    nElem = ((nElem * qWidth + pivotP) - leftP)/qWidth;
 
    /* Sort smaller partition first to reduce stack usage */
    if (nElem < lNum)
	{ qSortHelp (leftP, nElem);
	  nElem = lNum;
	}
    else
	{ qSortHelp (pivotP, lNum);
	  pivotP = leftP;
	}
    goto tailRecursion;
}
 
/*-----------------------------------------------------------------------*
Name            qsort - sorts using the quick sort routine
Usage           void qsort(void *base, int nelem, int width, int (*fcmp)());
Prototype in    stdlib.h
Description     qsort is an implementation of the "median of three"
		variant of the quicksort algorithm. qsort sorts the entries
		in a table into order by repeatedly calling the user-defined
		comparison function pointed to by fcmp.
 
		base points to the base (0th element) of the table to be sorted.
 
		nelem is the number of entries in the table.
 
		width is the size of each entry in the table, in bytes.
 
		*fcmp, the comparison function, accepts two arguments, elem1
		and elem2, each a pointer to an entry in the table. The
		comparison function compares each of the pointed-to items
		(*elem1 and *elem2), and returns an integer based on the result
		of the comparison.
 
			If the items            fcmp returns
 
			*elem1 <  *elem2         an integer < 0
			*elem1 == *elem2         0
			*elem1 >  *elem2         an integer > 0
 
		In the comparison, the less than symbol (<) means that the left
		element should appear before the right element in the final,
		sorted sequence. Similarly, the greater than (>) symbol
		means that the left element should appear after the right
		element in the final, sorted sequence.
 
Return value    qsort does not return a value.
 
*------------------------------------------------------------------------*/
 
void  Qsort(void *baseP, size_t nElem, size_t width, comparF *compar)
/*
  The table *baseP containing a count of nElem records each of fixed width
  is to be converted from unknown order into ascending order, using the
  ordering provided by the comparison function compar.
 
  The comparison function compar (leftP, rightP) must return less than, equal,
  or greater than zero, according to whether it decides that (record) *leftP
  is less than, equal, or greater than (record) *rightP.
 
  The internal contents of the records are never inspected by qsort.  It
  depends entirely upon compar to decide the format and value of the records.
  This allows the content of the records to be of any fixed length type -
  formatted text, floating point, pointer to variable length record, etc. -
  so long as each record is understood by compar.
 
  The quicker sort algorithm will in general change the relative ordering
  of records which may compare as equal.  For example, if it is attempted
  to use two passes of quick sort on a order file, first by date and then
  by customer name, the result will be that the second sort pass randomly
  jumbles the dates.  It is necessary to design the compar() function to
  consider all the keys and sort in one pass.
*/
 
 {
    if ((qWidth = width) == 0)	return;
    Fcmp = compar;
    qSortHelp (baseP, nElem);
 }
 
  void say( int * A , size_t nb )
   { size_t i ;
     for( i = 0 ; i < nb; i++ )
     printf("%d ", A[i] ) ;
     printf("\n");
   }
 
  void main()
   { puts("Begin");
     say( Array, max ) ;
     Qsort( Array, max, sizeof(int), (comparF*) intcomp ) ;
     say( Array, max ) ;
     puts("End");
     getchar();
   }

La médiane de trois...avec des "goto"... bref qsort fait le ménage.
Ma question vient du fait que l' arithmétique des pointeurs tient sur le ( char * ) et non pas sur le ( void * ).

Il me semble que la dernière mouture du C , permet l' arithmétique du pointeur sur ( void * ) .

Vous confirmez ou je me trompe ?

salut.

04/02/2007, 01h15
Emmanuel Delahaye

Citation:

Envoyé par dj.motte

Ma question vient du fait que l' arithmétique des pointeurs tient sur le ( char * ) et non pas sur le ( void * ).

Il me semble que la dernière mouture du C , permet l' arithmétique du pointeur sur ( void * ) .

Non. C'est une extension (bien malheureuse) de gcc...
04/02/2007, 01h28
dj.motte

Bonjour,

Emmanuel Delahaye écrit :

Citation:

Non. C'est une extension (ben malheureuse) de gcc...

Pourquoi malheureuse ?

Il me paraît normal que le type (void *) soit soummis à l' arithmétique des pointeurs.

Le problème est dans la reécriture des codes source.
Vous confirmez ?

salut.
04/02/2007, 09h05
Emmanuel Delahaye

Citation:

Envoyé par dj.motte

Pourquoi malheureuse ?

Il me paraît normal que le type (void *) soit soummis à l' arithmétique des pointeurs.

C'est contre la définition du langage C qui dit clairement que le type void n'a pas de taille connue et que donc l'arithmétique des pointeurs ne s'applique pas. Pour qu'elle s'applique, il faut un type explicite (typecast ou pointeur relais) différent de void.