soit le fragment de code suivant :
-------------------------------
struct mastruct {
unsigned int start,stop;
};
static int s_addrcmp_for_qsort(const void *a,const void *b )
{
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned int result;
result= ((line_a->start)>>2) - ((line_b->start)>>2);
return result;
}
-------------------------
je compile en -Wall -Wextra, etc... avec un gcc 4.0.2, et celui ci
se
fache en me disant :
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal, je lui en serais
éternellement reconnaissant....
TM.
soit le fragment de code suivant :
-------------------------------
struct mastruct {
unsigned int start,stop;
};
static int s_addrcmp_for_qsort(const void *a,const void *b )
{
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned int result;
result= ((line_a->start)>>2) - ((line_b->start)>>2);
return result;
}
-------------------------
je compile en -Wall -Wextra, etc... avec un gcc 4.0.2, et celui ci
se
fache en me disant :
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal, je lui en serais
éternellement reconnaissant....
TM.
soit le fragment de code suivant :
-------------------------------
struct mastruct {
unsigned int start,stop;
};
static int s_addrcmp_for_qsort(const void *a,const void *b )
{
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned int result;
result= ((line_a->start)>>2) - ((line_b->start)>>2);
return result;
}
-------------------------
je compile en -Wall -Wextra, etc... avec un gcc 4.0.2, et celui ci
se
fache en me disant :
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal, je lui en serais
éternellement reconnaissant....
TM.
soit tu appelles toujours la fonction s_addrcmp_for_qsort() avec,
comme argument, des struct mastruct. Auquel cas je ne vois pas
l'intérêt d'utiliser les types const void * en argument de fonction.
cette fonction est prototypée suivant un modele standart pour qsort:
Soit tu l'utilises sur des types qui ne sont pas des struct mastruct,
et là tu risques d'avoir des problèmes, car à priori, rien ne garanti
que la représentation mémoire de ta structure soit la même que celle
des autres types sur lesquel tu l'appliques. En particulier, il
pourrait y avoir des bits de padding entre tes deux unsigned int, ce
qui causerait des problèmes.
J'ai oublié de préciser que ce code fonctionne sous unix (freebsd, mac
soit tu appelles toujours la fonction s_addrcmp_for_qsort() avec,
comme argument, des struct mastruct. Auquel cas je ne vois pas
l'intérêt d'utiliser les types const void * en argument de fonction.
cette fonction est prototypée suivant un modele standart pour qsort:
Soit tu l'utilises sur des types qui ne sont pas des struct mastruct,
et là tu risques d'avoir des problèmes, car à priori, rien ne garanti
que la représentation mémoire de ta structure soit la même que celle
des autres types sur lesquel tu l'appliques. En particulier, il
pourrait y avoir des bits de padding entre tes deux unsigned int, ce
qui causerait des problèmes.
J'ai oublié de préciser que ce code fonctionne sous unix (freebsd, mac
soit tu appelles toujours la fonction s_addrcmp_for_qsort() avec,
comme argument, des struct mastruct. Auquel cas je ne vois pas
l'intérêt d'utiliser les types const void * en argument de fonction.
cette fonction est prototypée suivant un modele standart pour qsort:
Soit tu l'utilises sur des types qui ne sont pas des struct mastruct,
et là tu risques d'avoir des problèmes, car à priori, rien ne garanti
que la représentation mémoire de ta structure soit la même que celle
des autres types sur lesquel tu l'appliques. En particulier, il
pourrait y avoir des bits de padding entre tes deux unsigned int, ce
qui causerait des problèmes.
J'ai oublié de préciser que ce code fonctionne sous unix (freebsd, mac
soit le fragment de code suivant :
-------------------------------
struct mastruct {
unsigned int start,stop;
};
static int s_addrcmp_for_qsort(const void *a,const void *b )
{
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned int result;
result= ((line_a->start)>>2) - ((line_b->start)>>2);
return result;
}
-------------------------
je compile en -Wall -Wextra, etc... avec un gcc 4.0.2, et celui ci se
fache en me disant :
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal, je lui en serais
éternellement reconnaissant....
soit le fragment de code suivant :
-------------------------------
struct mastruct {
unsigned int start,stop;
};
static int s_addrcmp_for_qsort(const void *a,const void *b )
{
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned int result;
result= ((line_a->start)>>2) - ((line_b->start)>>2);
return result;
}
-------------------------
je compile en -Wall -Wextra, etc... avec un gcc 4.0.2, et celui ci se
fache en me disant :
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal, je lui en serais
éternellement reconnaissant....
soit le fragment de code suivant :
-------------------------------
struct mastruct {
unsigned int start,stop;
};
static int s_addrcmp_for_qsort(const void *a,const void *b )
{
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned int result;
result= ((line_a->start)>>2) - ((line_b->start)>>2);
return result;
}
-------------------------
je compile en -Wall -Wextra, etc... avec un gcc 4.0.2, et celui ci se
fache en me disant :
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal, je lui en serais
éternellement reconnaissant....
Je ne saurais pas dire pourquoi gcc gueule. Par contre, je sais que ce que tu
fais est dangereux. Peut être est-ce pour cela que gcc émet un warning :
soit tu appelles toujours la fonction s_addrcmp_for_qsort() avec, comme
argument, des struct mastruct. Auquel cas je ne vois pas l'intérêt d'utiliser
les types const void * en argument de fonction. Soit tu l'utilises sur des
types qui ne sont pas des struct mastruct, et là tu risques d'avoir des
problèmes, car à priori, rien ne garanti que la représentation mémoire de ta
structure soit la même que celle des autres types sur lesquel tu l'appliques.
En particulier, il pourrait y avoir des bits de padding entre tes deux
unsigned int, ce qui causerait des problèmes. Il existe une option gcc pour
compiler sans bits de padding dans les structures.
Je ne saurais pas dire pourquoi gcc gueule. Par contre, je sais que ce que tu
fais est dangereux. Peut être est-ce pour cela que gcc émet un warning :
soit tu appelles toujours la fonction s_addrcmp_for_qsort() avec, comme
argument, des struct mastruct. Auquel cas je ne vois pas l'intérêt d'utiliser
les types const void * en argument de fonction. Soit tu l'utilises sur des
types qui ne sont pas des struct mastruct, et là tu risques d'avoir des
problèmes, car à priori, rien ne garanti que la représentation mémoire de ta
structure soit la même que celle des autres types sur lesquel tu l'appliques.
En particulier, il pourrait y avoir des bits de padding entre tes deux
unsigned int, ce qui causerait des problèmes. Il existe une option gcc pour
compiler sans bits de padding dans les structures.
Je ne saurais pas dire pourquoi gcc gueule. Par contre, je sais que ce que tu
fais est dangereux. Peut être est-ce pour cela que gcc émet un warning :
soit tu appelles toujours la fonction s_addrcmp_for_qsort() avec, comme
argument, des struct mastruct. Auquel cas je ne vois pas l'intérêt d'utiliser
les types const void * en argument de fonction. Soit tu l'utilises sur des
types qui ne sont pas des struct mastruct, et là tu risques d'avoir des
problèmes, car à priori, rien ne garanti que la représentation mémoire de ta
structure soit la même que celle des autres types sur lesquel tu l'appliques.
En particulier, il pourrait y avoir des bits de padding entre tes deux
unsigned int, ce qui causerait des problèmes. Il existe une option gcc pour
compiler sans bits de padding dans les structures.
struct mastruct { unsigned int start,stop; };
static int s_addrcmp_for_qsort(const void *a,const void *b ) {
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned result=(line_a->start>>2) - (line_b->start>>2);
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal,
struct mastruct { unsigned int start,stop; };
static int s_addrcmp_for_qsort(const void *a,const void *b ) {
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned result=(line_a->start>>2) - (line_b->start>>2);
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal,
struct mastruct { unsigned int start,stop; };
static int s_addrcmp_for_qsort(const void *a,const void *b ) {
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned result=(line_a->start>>2) - (line_b->start>>2);
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal,
En news:4605462f$0$6655$, Truc Muche va escriure:struct mastruct { unsigned int start,stop; };
static int s_addrcmp_for_qsort(const void *a,const void *b ) {
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned result=(line_a->start>>2) - (line_b->start>>2);
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal,
Je ne sais pas si c'est la raison de l'avertissement (extrêmement trompeur
ÀMHA si c'est bien le cas),
Après de nombreux tests, ce warning est provoqué par -Wcast-qual.
mais il y a un souci dans la logique de ton code :
a->start est non signé, >>2 il reste toujours non signé, b->start idem, la
différence est donc non signée (si b->start est plus grand que a->start, le
résultat est une valeur très grande genre 0xFFFFFF??, qui sera sur x86-64
étendue _à zéro_ sur 64 bits), et quand la fonction renvoit un entier signé
tu as un possible cas de débordement entier.
En gros, c'est l'exemple typique de raisons pour lesquelles on recommande en
C d'utiliser des signed int pour des quantités comme start ou stop. Ici on
peut contourner avec un transtypage du résultat du décalage, mais cela
rajoute encore des couches de trantypages et des parenthèses et cela
obscurcit (ÀMHA) le code.
En news:4605462f$0$6655$426a74cc@news.free.fr, Truc Muche va escriure:
struct mastruct { unsigned int start,stop; };
static int s_addrcmp_for_qsort(const void *a,const void *b ) {
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned result=(line_a->start>>2) - (line_b->start>>2);
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal,
Je ne sais pas si c'est la raison de l'avertissement (extrêmement trompeur
ÀMHA si c'est bien le cas),
Après de nombreux tests, ce warning est provoqué par -Wcast-qual.
mais il y a un souci dans la logique de ton code :
a->start est non signé, >>2 il reste toujours non signé, b->start idem, la
différence est donc non signée (si b->start est plus grand que a->start, le
résultat est une valeur très grande genre 0xFFFFFF??, qui sera sur x86-64
étendue _à zéro_ sur 64 bits), et quand la fonction renvoit un entier signé
tu as un possible cas de débordement entier.
En gros, c'est l'exemple typique de raisons pour lesquelles on recommande en
C d'utiliser des signed int pour des quantités comme start ou stop. Ici on
peut contourner avec un transtypage du résultat du décalage, mais cela
rajoute encore des couches de trantypages et des parenthèses et cela
obscurcit (ÀMHA) le code.
En news:4605462f$0$6655$, Truc Muche va escriure:struct mastruct { unsigned int start,stop; };
static int s_addrcmp_for_qsort(const void *a,const void *b ) {
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned result=(line_a->start>>2) - (line_b->start>>2);
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal,
Je ne sais pas si c'est la raison de l'avertissement (extrêmement trompeur
ÀMHA si c'est bien le cas),
Après de nombreux tests, ce warning est provoqué par -Wcast-qual.
mais il y a un souci dans la logique de ton code :
a->start est non signé, >>2 il reste toujours non signé, b->start idem, la
différence est donc non signée (si b->start est plus grand que a->start, le
résultat est une valeur très grande genre 0xFFFFFF??, qui sera sur x86-64
étendue _à zéro_ sur 64 bits), et quand la fonction renvoit un entier signé
tu as un possible cas de débordement entier.
En gros, c'est l'exemple typique de raisons pour lesquelles on recommande en
C d'utiliser des signed int pour des quantités comme start ou stop. Ici on
peut contourner avec un transtypage du résultat du décalage, mais cela
rajoute encore des couches de trantypages et des parenthèses et cela
obscurcit (ÀMHA) le code.
Le shift de 2 permet justement de m'affranchir des débordements
d'entiers 32 bits lors de la soustraction et du retour de "result".
PS: sur toutes les machines 64 bits avec lesquelle j'ai travaillé
(sparc64, x86-64), un int était toujours en 32 bits (LP64):
le fait d'être sur une archi 64 bits n'a pas d'influence là.
Le shift de 2 permet justement de m'affranchir des débordements
d'entiers 32 bits lors de la soustraction et du retour de "result".
PS: sur toutes les machines 64 bits avec lesquelle j'ai travaillé
(sparc64, x86-64), un int était toujours en 32 bits (LP64):
le fait d'être sur une archi 64 bits n'a pas d'influence là.
Le shift de 2 permet justement de m'affranchir des débordements
d'entiers 32 bits lors de la soustraction et du retour de "result".
PS: sur toutes les machines 64 bits avec lesquelle j'ai travaillé
(sparc64, x86-64), un int était toujours en 32 bits (LP64):
le fait d'être sur une archi 64 bits n'a pas d'influence là.
soit le fragment de code suivant :
-------------------------------
struct mastruct {
unsigned int start,stop;
};
static int s_addrcmp_for_qsort(const void *a,const void *b )
{
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned int result;
result= ((line_a->start)>>2) - ((line_b->start)>>2);
return result;
}
-------------------------
je compile en -Wall -Wextra, etc... avec un gcc 4.0.2, et celui ci se
fache en me disant :
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal, je lui en serais
éternellement reconnaissant....
TM.
soit le fragment de code suivant :
-------------------------------
struct mastruct {
unsigned int start,stop;
};
static int s_addrcmp_for_qsort(const void *a,const void *b )
{
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned int result;
result= ((line_a->start)>>2) - ((line_b->start)>>2);
return result;
}
-------------------------
je compile en -Wall -Wextra, etc... avec un gcc 4.0.2, et celui ci se
fache en me disant :
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal, je lui en serais
éternellement reconnaissant....
TM.
soit le fragment de code suivant :
-------------------------------
struct mastruct {
unsigned int start,stop;
};
static int s_addrcmp_for_qsort(const void *a,const void *b )
{
const struct mastruct *line_a=(const struct mastruct *)a,
*line_b=(const struct mastruct *)b;
unsigned int result;
result= ((line_a->start)>>2) - ((line_b->start)>>2);
return result;
}
-------------------------
je compile en -Wall -Wextra, etc... avec un gcc 4.0.2, et celui ci se
fache en me disant :
warning: cast discards qualifiers from pointer target type
sur la ligne : result= ((line_a->start)>>2) - ((line_b->start)>>2);
Si quelqu'un pouvait me dire ce que je fais de mal, je lui en serais
éternellement reconnaissant....
TM.
Je ne saurais pas dire pourquoi gcc gueule. Par contre, je sais que ce
que tu fais est dangereux. Peut être est-ce pour cela que gcc émet un
warning :
soit tu appelles toujours la fonction s_addrcmp_for_qsort() avec,
comme argument, des struct mastruct. Auquel cas je ne vois pas
l'intérêt d'utiliser les types const void * en argument de fonction.
Je ne saurais pas dire pourquoi gcc gueule. Par contre, je sais que ce
que tu fais est dangereux. Peut être est-ce pour cela que gcc émet un
warning :
soit tu appelles toujours la fonction s_addrcmp_for_qsort() avec,
comme argument, des struct mastruct. Auquel cas je ne vois pas
l'intérêt d'utiliser les types const void * en argument de fonction.
Je ne saurais pas dire pourquoi gcc gueule. Par contre, je sais que ce
que tu fais est dangereux. Peut être est-ce pour cela que gcc émet un
warning :
soit tu appelles toujours la fonction s_addrcmp_for_qsort() avec,
comme argument, des struct mastruct. Auquel cas je ne vois pas
l'intérêt d'utiliser les types const void * en argument de fonction.