Discussion :

[valkheim]

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 :

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

[Médinoc]

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 :

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

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

Voire:

Code :

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

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

[Sve@r]

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 :

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

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 :

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

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 c :

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

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 :

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

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

[valkheim]

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 :

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

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

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

[Sve@r]

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

[valkheim]

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.