Discussion :

[dj.motte]

Bonjour,

D' ou vient l' erreur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[spawntux]

Bonsoir

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.

[Thierry Chappuis]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[spawntux]

Ok lol c'est donc ce que je disait enfin dans les grande ligne mdr ^^^^

[Emmanuel Delahaye]

Bonjour,

D' ou vient l' erreur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

   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".

[dj.motte]

Bonjour,

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.

[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!

[dj.motte]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Emmanuel Delahaye]

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.

[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.

[dj.motte]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[souviron34]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

[Emmanuel Delahaye]

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

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

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

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

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.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
   TR const *e1 = *ppa;
   TR const *e2 = *ppb;

maintenant, on peut accéder aux éléments :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
   return strcmp ( e1->z , e2->z );
}

Affaire reglée.

[Emmanuel Delahaye]

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

Un tableau, quoi.

Soit la structure :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

   T a[n];

2.2 - soit dynamiquement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   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 *.

[dj.motte]

Bonjour,

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

[dj.motte]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Médinoc]

NON : Perte de const-correctness, inutile qui plus est.

[dj.motte]

Bonjour,

D' accord pas de changement pour cmp.
Maintenant dans

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.