Discussion :

[salif98]

salut à tous, voilà j'ai un probleme, je n'arrive pas à comprendre ce ceci:
*(int *)a; pouvez vous m'eclairssir là-dessus ? je l'ai vu en cherchant des infos sur la fonction qsort, dans cette fonction qsort se trouve un appel à une fonction compare et c'est dans la fonction compare que j'ai vu cette ligne.
pour etre claire voici un lien où trouver cette fonction qsort pour ceux qui ne l'ont pas encore vu : http://www.cplusplus.com/ref/cstdlib/qsort.html
Merci d'avance

[frenchi]

Salut,

a est un pointeur sur n'importe quoi (void *).

Or on travaille sur des entiers, donc on veut que a soit un pointeur d'entier.
On cast donc a,

Code :

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

(int *)a

a devient donc un pointeur d'entier

Puis on accède à la valeur pointée par a grçace à l'opérateur *

*(int *)a renvoie la valeur pointé par a (un int).

[Franck.H]

Code :

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

1
2
3
4
5
 
int compare (const void * a, const void * b)
{
  return ( *(int*)a - *(int*)b );
}

Ici les argument sont des pointeur générique donc en fait il faut caster les donner dans leur type d'origine pour pouvoir effectuer une comparaison, ce qu'on fait avec:

Code :

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

(int *)

vu qu'il s'agit d'un pointeur.

Ensuite, pour récupérer la valeur stockée par un pointeur tu le fait naturellement comme ceci

Code :

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

*une_variable

Tu entrevois la chose ?

[salif98]

Ah ok, si je comprends bien, dans le cas où on aurait plutot declaré compare comme ceci:

Code :

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

1
2
3
4
int compare ( const int *a,const int *b)
{
  return (*a - *b);
}

?
et donc on juste convertir le pointeur generique void* en un pointeur d'entier ?

[Franck.H]

Ah ok, si je comprends bien, dans le cas où on aurait plutot declaré compare comme ceci:

Code :

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

1
2
3
4
int compare ( const int *a,const int *b)
{
  return (*a - *b);
}

?
et donc on juste convertir le pointeur generique void* en un pointeur d'entier ?

Oui

[Médinoc]

Sauf que le (int*) peut convertir n'importe quoi en pointeur d'entier.
En C, je trouve qu'il est plus propre d'utiliser:

Code :

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

1
2
3
4
5
6
7
int compare ( void const * pcgA, void const * pcgB)
{
int const * pcA = pcgA;
int const * pcB = pcgB;
 
return (*pcA - *pcB);
}

Ici en C, aucun cast n'est nécessaire, donc aucun risque changement intempestif de niveau d'indirection...

[Emmanuel Delahaye]

En C, je trouve qu'il est plus propre d'utiliser:

Code :

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

1
2
3
4
5
6
7
int compare ( void const * pcgA, void const * pcgB)
{
int const * pcA = pcgA;
int const * pcB = pcgB;
 
return (*pcA - *pcB);
}

Ici en C, aucun cast n'est nécessaire, donc aucun risque changement intempestif de niveau d'indirection...

+1

[Franck.H]

Oui et c'est surtout plus lisible

[Jean-Marc.Bourguet]

Ici en C, aucun cast n'est nécessaire, donc aucun risque changement intempestif de niveau d'indirection...

Ah? Ceci n'est pas un changement intempestif de niveau d'indirection?

Code :

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

1
2
3
4
5
6
7
int compare ( void const * pcgA, void const * pcgB)
{
int const ** pcA = pcgA;
int const * pcB = pcgB;
 
return (**pcA - *pcB);
}

[Jean-Marc.Bourguet]

Oui et c'est surtout plus lisible

Vous me permettrez un avis divergent. Je n'aime pas trop les conversions implicites quand elles ne sont pas garanties statiquement d'être valables. void* -> X* n'est pas garanti valable et je préfère expliciter le cast.
X* -> void* est garanti valable, je préfère l'absence de cast (en fait il y a des conversions garanties où je préfère aussi le cast, il faudra que je réfléchisse une fois au pourquoi).

[Emmanuel Delahaye]

Vous me permettrez un avis divergent. Je n'aime pas trop les conversions implicites quand elles ne sont pas garanties statiquement d'être valables. void* -> X* n'est pas garanti valable et je préfère expliciter le cast.
X* -> void* est garanti valable, je préfère l'absence de cast (en fait il y a des conversions garanties où je préfère aussi le cast, il faudra que je réfléchisse une fois au pourquoi).

A ma connaissance les conversions sont garanties dans les 2 sens en C.

[Médinoc]

Ah? Ceci n'est pas un changement intempestif de niveau d'indirection?

Code :

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

1
2
3
4
5
6
7
int compare ( void const * pcgA, void const * pcgB)
{
int const ** pcA = pcgA;
int const * pcB = pcgB;
 
return (**pcA - *pcB);
}

Oups J'avais oublié que void* était aussi compatible avec les pointeurs de pointeurs... Le seul niveau d'indirection qu'il interdit, c'est le niveau zéro...

[Jean-Marc.Bourguet]

A ma connaissance les conversions sont garanties dans les 2 sens en C.

Par pas garanti, je faisais allusion à

Code :

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

1
2
3
4
5
char foo[4];
char *bar = &foo[1];
void *baz = bar;
int *bat = baz;
int qux = *bat;

Boum! sur ma machine et pas la moindre indication d'une conversion douteuse.

[Emmanuel Delahaye]

Par pas garanti, je faisais allusion à

Code :

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

1
2
3
4
5
char foo[4];
char *bar = &foo[1];
void *baz = bar;
int *bat = baz;
int qux = *bat;

Boum! sur ma machine et pas la moindre indication d'une conversion douteuse.

La souplesse implique de nouvelles responsabilités ! On ne peut évidemment pas faire n'importe quoi.

Il me semble qu'un compilateur pour machines à alignement pair (Freescale, 68k, PPC), il y aurait eu un warning sur les risques de 'misalignment'... Mais le compilateur ne peut pas toujours tout voir et il est dangereux de compter dessus...

[Jean-Marc.Bourguet]

La souplesse implique de nouvelles responsabilités ! On ne peut évidemment pas faire n'importe quoi.

Je préfère que les endroits dangereux soient marqués, même si ce n'est pas obligatoire. J'aurais préféré que ce soit obligatoire, un void* qui se transforme en autre chose que ce qu'on désire -- parce qu'on a inversé deux arguments dans un appel de fonction par exemple -- c'est un peu trop facile à avoir.

[Emmanuel Delahaye]

Je préfère que les endroits dangereux soient marqués, même si ce n'est pas obligatoire. J'aurais préféré que ce soit obligatoire, un void* qui se transforme en autre chose que ce qu'on désire -- parce qu'on a inversé deux arguments dans un appel de fonction par exemple -- c'est un peu trop facile à avoir.

On ne peut pas non plus être assisté tout le temps... Parfois, il faut accepter de vivre dangereusement, sinon, à la longue, c'est chi*nt...

[Jean-Marc.Bourguet]

On ne peut pas non plus être assisté tout le temps... Parfois, il faut accepter de vivre dangereusement, sinon, à la longue, c'est chi*nt...

Pour vivre dangereusement, les schedules qu'on a me suffisent amplement. Passer du temps à débugger à cause de ce genre d'erreur, j'aime pas. Si tu veux te passer de la vérification de type, tu peux essayer BCPL si tu veux.

[Médinoc]

C'est pour ça que j'ai tendance à préférer les casts C++ (bien que là encore, ils ne soient pas assez restrictifs à mon gout)

• static_cast<>() pour les conversions de nombres, ou de void* vers type*, ou ClasseDeBase* vers ClasseDerivee*
• reinterpret_cast<>() pour les conversions truc* vers machin*, mais hélas, aussi pour les conversions pointeur/entier : j'aurais préféré deux opérateurs différents, dont l'un restreint aux pointeurs...
• const_cast<>() pour éliminer un attribut const ou volatile

[Emmanuel Delahaye]

C'est pour ça que j'ai tendance à préférer les casts C++ <...>

Ben oui, mais en C, on fait comme on peut...