comparaison strcmp de void *

Bonjour,

J'ai deux void * que je voudrais comparer à la manière d'un strcmp.
J'y arrive avec des char * mais je n'y parviens pas en envoyant des void * ou en castant mes char * pour du void *

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

int cmp_w_str(char *s1, char *s2) { int i;   i = 0; while (s1[i] != '\0') { if (s1[i] < s2[i]) return (-1); if (s1[i] > s2[i]) return (1); i++; } return (0); }

---

Ci dessus ma fonction à la strcmp qui compare mes deux char *

Comment peut-on le réaliser avec des void * passés en paramètres ?
Peut on le faire en castant les void * pour du char * ?

Tu ne peux pas comparer autre chose que des chaînes de caractères avec une fonction ne prenant que des pointeurs en paramètre, car tu ne sauras pas où t'arrêter!

une bonne fonction de comparaison aura un prototype de ce genre:

Code:

---

1 2	int voidcmp(const void *a, const void*b, size_t size) {

---

Voire:

Code:

---

1 2	int voidcmp(const void *a, const void*b, size_t sizeA, size_t sizeB) {

---

Ensuite pour la comparaison elle-même, il vaudra convertir en unsigned char const * pour obtenir les bytes pointés, vu qu'on ne peut pas déréférencer un void*.

Citation:

---

Envoyé par valkheim

J'ai deux void * que je voudrais comparer à la manière d'un strcmp.
J'y arrive avec des char * mais je n'y parviens pas en envoyant des void * ou en castant mes char * pour du void *

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int cmp_w_str(char *s1, char *s2) { int i;   i = 0; while (s1[i] != '\0') { if (s1[i] < s2[i]) return (-1); if (s1[i] > s2[i]) return (1); i++; } return (0); }

---

Comment peut-on le réaliser avec des void * passés en paramètres ?
Peut on le faire en castant les void * pour du char * ?

---

Bonjour

Déjà tu as un comportement indéterminé si s2 est plus petite (en terme de longueur de chaine) que s1 car dans ce cas là, tu tapes au delà de sa plage légale.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

int cmp_w_str(char *s1, char *s2) { char *pt1=s1; char *pt2=s2;   do { if (*pt1 < *pt2) return -1; if (*pt1 > *pt2) return 1; } while (*pt1++ && *pt2++); return 0; }

---

En ce qui concerne ton pb de void*, te suffit de caster tes void* en char* lors de l'appel
Exemple

Code:

---

1 2 3

void *xxx; void *yyy; cmp_w_str(char*)xxx, (char*)yyy);

---

En considérant bien entendu que ces pointeurs "void" pointent quand-même vers des suites de caractère contenant un '\0'.

Si maintenant tu veux écrire une fonction acceptant des void* (cela semble étrange pour une telle fonction sensée manipuler ce qu'elle reçoit comme du caractère), alors il te suffit d'écrire son début ainsi

Code:

---

1 2 3 4 5 6

int cmp_w_str(void *s1, void *s2) { char *pt1=(char*)s1; char *pt2=(char*)s2; ... (le reste sans changement)... }

---

PS: je ne suis pas certain que le cast soit obligatoire (ça dépend des options de compilation)...

Merci pour vos réponses :)

La comparaison fonctionne désormais bien avec mes void *
Pourtant j'ai quelques problèmes avec la longueur. Il fonctionne bien aux tests unitaires mais pas quand j'essaie de boucler l'affaire :/
Je m'explique : j'ai deux listes contenant des nombres dans des void * à trier.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

int voidcmp(const void *a, const void *b) { unsigned char const *s1 = a; unsigned char const *s2 = b; int i;   i = 0; if (my_strlen(s1) < my_strlen(s2)) return (-1); else while (s1[i] != '\0') { if (s1[i] < s2[i]) return (-1); if (s1[i] > s2[i]) return (1); i++; } return (0); }

---

Voici ma fonction de comparaison avec les void *, elle fonctionne bien il me semble.

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

int bubble(t_dllist **head_a, t_dllist **head_\ b) { t_dllist *current_a; t_dllist *current_b; char *small; int index;   current_a = *head_a; current_b = *head_b;   if (current_a == NULL) return (0); small = smallest_of(head_a); index = smallest_of_index(&current_a, small); while (index > 0) { rotate_a(&current_a); index--; } put_in_b(head_a, head_b); bubble(head_a, head_b); }

---

Ici j'effectue mon tri. Il fonctione avec des chiffres mais me renvoie un mauvais placement pour les nombres supérieurs ou égaux à 10.
Cette fonction prend deux listes a et b en paramètres. Elle parcours la liste a en trouvant le plus petit élément (smallest of a)
Elle va ensuite récupérer l'indice du plus petit élément.
Elle effectue u rotate vers la gauche de la liste a jusqu'à ce qu'il soit au début. Le rôle de put_in_b est ensuite de faire passer le premier élément de a (le plus petit) dans la liste b. Elle le place au début.
Je fais enfin "boucler" le tout jusqu'à ce que ma liste a soit vide.

Ex :

Entrée
liste_a :: 2:1:3:6:5:8:
liste_b ::

Sortie
liste_a ::
liste_b :: 8:6:5:3:2:1

Et avec des nombres plus grands que 9

Entrée
liste_a :: 2:10:3:6:5:8:
liste_b ::

Sortie
liste_a ::
liste_b :: 8:5:6:3:10:2:

Comment arranger celà ? :/
J'ai l'impression qu'il ne s'agit que d'une ou plusieurs erreurs de parcours de liste..

EDIT2 :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

int voidcmp(const void *a, const void *b) { unsigned char const *s1 = a; unsigned char const *s2 = b; int i;   i = -1; if (my_strlen(s1) < my_strlen(s2)) return (-1); else if (my_strlen(s1) > my_strlen(s2)) return (1); else while (s1[++i] != '\0') if (s1[i] < s2[i]) return (-1); else if (s1[i] > s2[i]) return (1); return (0); }

---

Citation:

---

Envoyé par valkheim

Ici j'effectue mon tri. Il fonctione avec des chiffres mais me renvoie un mauvais placement pour les nombres supérieurs ou égaux à 10.
Entrée
liste_a :: 2:10:3:6:5:8:
liste_b ::

Sortie
liste_a ::
liste_b :: 8:5:6:3:10:2:

J'ai l'impression qu'il ne s'agit que d'une ou plusieurs erreurs de parcours de liste..

---

Non, c'est plutôt qu'en comparaison alphabétique (ce que fait strlen), 1 ('1', '\0') est plus petit que 10 ('1', '0', '\0') et lui-même est plus petit que 2 ('2', '\0')...
Ben oui, la comparaison se fait caractère par caractère. Or quand il compare 10 et 2, il commence par comparer '1' et '2' et là, ben il s'arrête...

Oui tout à fait.
Le problème a été fixé en rajoutant le retour 1 si s2 était plus longue que s1.
Je ne considérais jusqu'alors pas la rotation des éléments dans ma liste et j'avais donc ommis ce cas.