utiliser qsort avec void**

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 *));

---

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.

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

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

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

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.

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

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.

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

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.

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

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

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

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

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