Decalages d'un nombre de bits pouvant etre >= a la taille du type
134 réponses
Vincent Lefevre
J'ai besoin de faire un décalage vers la droite sur un type entier
(disons non signé) générique (i.e. défini par typedef) d'un certain
nombre constant de bits. Le problème est que ce nombre de bits peut
être supérieur ou égal à la taille du type en question. Une idée
sur la façon de faire ça efficacement sans obtenir de comportement
indéfini et sans passer par un outil du style "configure"?
La langue économique (Hong Kong, Canton) est le cantonnais...
-- Emmanuel The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html The C-library: http://www.dinkumware.com/refxc.html
"C is a sharp tool"
Antoine Leca
En , Emmanuel Delahaye va escriure:
Laurent Deniau wrote on 07/10/04 :
Je parle chinois? relis ce que j'ai ecrit stp...
Il n'y a pas plus de "chinois" que d'"européen".
En langue parlée, oui. En langue écrite (ce qui est le cas ici), non.
Il faut préciser (mandarain, cantonnais, ... il y a une soixantaine de langues en Chine...)
Il y a plus de langues que cela, mais elles ne s'écrivent pas toutes comme le chinois. Par exemple, l'ouïghour est une langue complètement différente.
Je crois qu'il y a 8 dialectes (c'est comme cela que l'on les nomme habituellement, même si c'est impropre) principaux, donc le mandarin (¾), le wou, le cantonais, le min, le hakka.
Antoine
En mn.437e7d4a4325e074.15512@YOURBRAnoos.fr, Emmanuel Delahaye va escriure:
Laurent Deniau wrote on 07/10/04 :
Je parle chinois? relis ce que j'ai ecrit stp...
Il n'y a pas plus de "chinois" que d'"européen".
En langue parlée, oui.
En langue écrite (ce qui est le cas ici), non.
Il faut préciser (mandarain, cantonnais, ... il y a une soixantaine
de langues en Chine...)
Il y a plus de langues que cela, mais elles ne s'écrivent pas toutes comme
le chinois. Par exemple, l'ouïghour est une langue complètement différente.
Je crois qu'il y a 8 dialectes (c'est comme cela que l'on les nomme
habituellement, même si c'est impropre) principaux, donc le mandarin (¾), le
wou, le cantonais, le min, le hakka.
En langue parlée, oui. En langue écrite (ce qui est le cas ici), non.
Il faut préciser (mandarain, cantonnais, ... il y a une soixantaine de langues en Chine...)
Il y a plus de langues que cela, mais elles ne s'écrivent pas toutes comme le chinois. Par exemple, l'ouïghour est une langue complètement différente.
Je crois qu'il y a 8 dialectes (c'est comme cela que l'on les nomme habituellement, même si c'est impropre) principaux, donc le mandarin (¾), le wou, le cantonais, le min, le hakka.
Antoine
Charlie Gordon
"Antoine Leca" wrote in message news:ck63tm$9gm$
Mais continuez à chercher, les gars. Si quelqu'un trouve un moyen de passer
outre l'utilisation de <limits.h>, je suis preneur...
La question de Vincent est comment faire pour éviter "configure" ou similaire. On peut donc utiliser <limits.h> et le preprocesseur:
#include <limits.h>
#if (INT_MAX >> 15) == 1 // on est en 16 bits #elif (INT_MAX >> 31) == 1 // ici les int font 32 bits #elif (INT_MAX >> 63) == 1 // super des gros int de 64 bits #else // toto, mais ou sommes nous ? plus au Kansas en tout cas. #endif
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans limits.h des définitions pour le nombre de bits des différents types. Mais il est vrai que rien n'oblige à ce que l'arithmétique se fasse en base 2.
Chqrlie
"Antoine Leca" <root@localhost.gov> wrote in message
news:ck63tm$9gm$1@shakotay.alphanet.ch...
Mais continuez à chercher, les gars. Si quelqu'un trouve un moyen de
passer
outre l'utilisation de <limits.h>, je suis preneur...
La question de Vincent est comment faire pour éviter "configure" ou
similaire.
On peut donc utiliser <limits.h> et le preprocesseur:
#include <limits.h>
#if (INT_MAX >> 15) == 1
// on est en 16 bits
#elif (INT_MAX >> 31) == 1
// ici les int font 32 bits
#elif (INT_MAX >> 63) == 1
// super des gros int de 64 bits
#else
// toto, mais ou sommes nous ? plus au Kansas en tout cas.
#endif
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans limits.h
des définitions pour le nombre de bits des différents types. Mais il est
vrai que rien n'oblige à ce que l'arithmétique se fasse en base 2.
Mais continuez à chercher, les gars. Si quelqu'un trouve un moyen de passer
outre l'utilisation de <limits.h>, je suis preneur...
La question de Vincent est comment faire pour éviter "configure" ou similaire. On peut donc utiliser <limits.h> et le preprocesseur:
#include <limits.h>
#if (INT_MAX >> 15) == 1 // on est en 16 bits #elif (INT_MAX >> 31) == 1 // ici les int font 32 bits #elif (INT_MAX >> 63) == 1 // super des gros int de 64 bits #else // toto, mais ou sommes nous ? plus au Kansas en tout cas. #endif
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans limits.h des définitions pour le nombre de bits des différents types. Mais il est vrai que rien n'oblige à ce que l'arithmétique se fasse en base 2.
Chqrlie
Richard Delorme
"Antoine Leca" wrote in message news:ck63tm$9gm$
Mais continuez à chercher, les gars. Si quelqu'un trouve un moyen de
passer
outre l'utilisation de <limits.h>, je suis preneur...
La question de Vincent est comment faire pour éviter "configure" ou similaire. On peut donc utiliser <limits.h> et le preprocesseur:
#include <limits.h>
#if (INT_MAX >> 15) == 1 // on est en 16 bits #elif (INT_MAX >> 31) == 1 // ici les int font 32 bits #elif (INT_MAX >> 63) == 1 // super des gros int de 64 bits #else // toto, mais ou sommes nous ? plus au Kansas en tout cas. #endif
Ça ne marche pas, ça trouve toujours des int de 16 bits.
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans limits.h des définitions pour le nombre de bits des différents types. Mais il est vrai que rien n'oblige à ce que l'arithmétique se fasse en base 2.
Si, en C, l'arithmétique entière est nécessairement en base 2. Par contre il peut y avoir des bits de padding, ce qui complique le calcul de la largeur d'un nombre entier.
-- Richard
"Antoine Leca" <root@localhost.gov> wrote in message
news:ck63tm$9gm$1@shakotay.alphanet.ch...
Mais continuez à chercher, les gars. Si quelqu'un trouve un moyen de
passer
outre l'utilisation de <limits.h>, je suis preneur...
La question de Vincent est comment faire pour éviter "configure" ou
similaire.
On peut donc utiliser <limits.h> et le preprocesseur:
#include <limits.h>
#if (INT_MAX >> 15) == 1
// on est en 16 bits
#elif (INT_MAX >> 31) == 1
// ici les int font 32 bits
#elif (INT_MAX >> 63) == 1
// super des gros int de 64 bits
#else
// toto, mais ou sommes nous ? plus au Kansas en tout cas.
#endif
Ça ne marche pas, ça trouve toujours des int de 16 bits.
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans limits.h
des définitions pour le nombre de bits des différents types. Mais il est
vrai que rien n'oblige à ce que l'arithmétique se fasse en base 2.
Si, en C, l'arithmétique entière est nécessairement en base 2. Par
contre il peut y avoir des bits de padding, ce qui complique le calcul
de la largeur d'un nombre entier.
Mais continuez à chercher, les gars. Si quelqu'un trouve un moyen de
passer
outre l'utilisation de <limits.h>, je suis preneur...
La question de Vincent est comment faire pour éviter "configure" ou similaire. On peut donc utiliser <limits.h> et le preprocesseur:
#include <limits.h>
#if (INT_MAX >> 15) == 1 // on est en 16 bits #elif (INT_MAX >> 31) == 1 // ici les int font 32 bits #elif (INT_MAX >> 63) == 1 // super des gros int de 64 bits #else // toto, mais ou sommes nous ? plus au Kansas en tout cas. #endif
Ça ne marche pas, ça trouve toujours des int de 16 bits.
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans limits.h des définitions pour le nombre de bits des différents types. Mais il est vrai que rien n'oblige à ce que l'arithmétique se fasse en base 2.
Si, en C, l'arithmétique entière est nécessairement en base 2. Par contre il peut y avoir des bits de padding, ce qui complique le calcul de la largeur d'un nombre entier.
-- Richard
Antoine Leca
En ck698e$ssu$, Charlie Gordon va escriure:
La question de Vincent est comment faire pour éviter "configure" ou similaire. On peut donc utiliser <limits.h>
Oui, cela je le sais. Mais si on me trouve un moyen d'éviter la cascade de #elif, ce serait plus joli...
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans limits.h des définitions pour le nombre de bits des différents types.
CHAR_BIT * sizeof(t), c'est pas bon pour toi ?
Ou alors tu veux le nombre de bits significatifs (sans le remplissage)? Pour les non signés, tu peux le faire avec Umachin_MAX, mais c'est vrai que pour les signés c'est plus taquin. Avec C99, on a la garantie que à partir de machin_MAX tu peux calculer le nombre de bits de la partie positive, +1 pour le bit de signe.
Bien sûr, tout ceci n'est pas disponible au niveau du préprocesseur. Là, il faut se contenter de machin_MAX (ce qui est déjà ça).
Mais il est vrai que rien n'oblige à ce que l'arithmétique se fasse en base 2.
Depuis C99, les seules représentations possibles pour les entiers sont binaires (6.2.6.2); avec C90 c'est vrai que tu pouvais avoir d'autres représentations, mais la pratique n'en a pas montré beaucoup...
Antoine
En ck698e$ssu$1@news.tiscali.fr, Charlie Gordon va escriure:
La question de Vincent est comment faire pour éviter "configure" ou
similaire. On peut donc utiliser <limits.h>
Oui, cela je le sais.
Mais si on me trouve un moyen d'éviter la cascade de #elif, ce serait plus
joli...
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans
limits.h des définitions pour le nombre de bits des différents types.
CHAR_BIT * sizeof(t), c'est pas bon pour toi ?
Ou alors tu veux le nombre de bits significatifs (sans le remplissage)? Pour
les non signés, tu peux le faire avec Umachin_MAX, mais c'est vrai que pour
les signés c'est plus taquin. Avec C99, on a la garantie que à partir de
machin_MAX tu peux calculer le nombre de bits de la partie positive, +1 pour
le bit de signe.
Bien sûr, tout ceci n'est pas disponible au niveau du préprocesseur. Là, il
faut se contenter de machin_MAX (ce qui est déjà ça).
Mais il est vrai que rien n'oblige à ce que l'arithmétique se fasse
en base 2.
Depuis C99, les seules représentations possibles pour les entiers sont
binaires (6.2.6.2); avec C90 c'est vrai que tu pouvais avoir d'autres
représentations, mais la pratique n'en a pas montré beaucoup...
La question de Vincent est comment faire pour éviter "configure" ou similaire. On peut donc utiliser <limits.h>
Oui, cela je le sais. Mais si on me trouve un moyen d'éviter la cascade de #elif, ce serait plus joli...
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans limits.h des définitions pour le nombre de bits des différents types.
CHAR_BIT * sizeof(t), c'est pas bon pour toi ?
Ou alors tu veux le nombre de bits significatifs (sans le remplissage)? Pour les non signés, tu peux le faire avec Umachin_MAX, mais c'est vrai que pour les signés c'est plus taquin. Avec C99, on a la garantie que à partir de machin_MAX tu peux calculer le nombre de bits de la partie positive, +1 pour le bit de signe.
Bien sûr, tout ceci n'est pas disponible au niveau du préprocesseur. Là, il faut se contenter de machin_MAX (ce qui est déjà ça).
Mais il est vrai que rien n'oblige à ce que l'arithmétique se fasse en base 2.
Depuis C99, les seules représentations possibles pour les entiers sont binaires (6.2.6.2); avec C90 c'est vrai que tu pouvais avoir d'autres représentations, mais la pratique n'en a pas montré beaucoup...
Antoine
Charlie Gordon
"Richard Delorme" wrote in message news:4166b2ff$0$15753$
On peut donc utiliser <limits.h> et le preprocesseur:
#include <limits.h>
#if (INT_MAX >> 15) == 1 // on est en 16 bits #elif (INT_MAX >> 31) == 1 // ici les int font 32 bits #elif (INT_MAX >> 63) == 1 // super des gros int de 64 bits #else // toto, mais ou sommes nous ? plus au Kansas en tout cas. #endif
Ça ne marche pas, ça trouve toujours des int de 16 bits.
C'est effectivement faux, mais je n'ai pas le même diagnostique : en l'occurrence, ça trouve toujours le pays des merveilles !
Je me suis trompé sur le décalage, on pourra vérifier qu'il fallait écrire :
#include <stdio.h> #include <limits.h>
int main(void) { printf("INT_MAX = %d -> %sn", INT_MAX, #if (INT_MAX >> 14) == 1 "on est en 16 bits" #elif (INT_MAX >> 30) == 1 "ici les int font 32 bits" #elif (INT_MAX >> 62) == 1 "super des gros int de 64 bits" #else "toto, mais ou sommes nous ? plus au Kansas en tout cas" #endif ); return 0; }
désolé,
Chqrlie
"Richard Delorme" <abulmo@nospam.fr> wrote in message
news:4166b2ff$0$15753$7a628cd7@news.club-internet.fr...
On peut donc utiliser <limits.h> et le preprocesseur:
#include <limits.h>
#if (INT_MAX >> 15) == 1
// on est en 16 bits
#elif (INT_MAX >> 31) == 1
// ici les int font 32 bits
#elif (INT_MAX >> 63) == 1
// super des gros int de 64 bits
#else
// toto, mais ou sommes nous ? plus au Kansas en tout cas.
#endif
Ça ne marche pas, ça trouve toujours des int de 16 bits.
C'est effectivement faux, mais je n'ai pas le même diagnostique : en
l'occurrence, ça trouve toujours le pays des merveilles !
Je me suis trompé sur le décalage, on pourra vérifier qu'il fallait écrire :
#include <stdio.h>
#include <limits.h>
int main(void) {
printf("INT_MAX = %d -> %sn", INT_MAX,
#if (INT_MAX >> 14) == 1
"on est en 16 bits"
#elif (INT_MAX >> 30) == 1
"ici les int font 32 bits"
#elif (INT_MAX >> 62) == 1
"super des gros int de 64 bits"
#else
"toto, mais ou sommes nous ? plus au Kansas en tout cas"
#endif
);
return 0;
}
"Richard Delorme" wrote in message news:4166b2ff$0$15753$
On peut donc utiliser <limits.h> et le preprocesseur:
#include <limits.h>
#if (INT_MAX >> 15) == 1 // on est en 16 bits #elif (INT_MAX >> 31) == 1 // ici les int font 32 bits #elif (INT_MAX >> 63) == 1 // super des gros int de 64 bits #else // toto, mais ou sommes nous ? plus au Kansas en tout cas. #endif
Ça ne marche pas, ça trouve toujours des int de 16 bits.
C'est effectivement faux, mais je n'ai pas le même diagnostique : en l'occurrence, ça trouve toujours le pays des merveilles !
Je me suis trompé sur le décalage, on pourra vérifier qu'il fallait écrire :
#include <stdio.h> #include <limits.h>
int main(void) { printf("INT_MAX = %d -> %sn", INT_MAX, #if (INT_MAX >> 14) == 1 "on est en 16 bits" #elif (INT_MAX >> 30) == 1 "ici les int font 32 bits" #elif (INT_MAX >> 62) == 1 "super des gros int de 64 bits" #else "toto, mais ou sommes nous ? plus au Kansas en tout cas" #endif ); return 0; }
désolé,
Chqrlie
Charlie Gordon
"Antoine Leca" wrote in message news:ck6d3g$nso$
En ck698e$ssu$, Charlie Gordon va escriure:
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans limits.h des définitions pour le nombre de bits des différents types.
CHAR_BIT * sizeof(t), c'est pas bon pour toi ?
Dans ce thread on veut faire des tests au niveau du préprocesseur ;-)
Chqrlie.
PS: C'est vrai que les cascades de #elif, c'est ni beau, ni exhaustif, mais c'est quand même pas loin du but.
"Antoine Leca" <root@localhost.gov> wrote in message
news:ck6d3g$nso$2@shakotay.alphanet.ch...
En ck698e$ssu$1@news.tiscali.fr, Charlie Gordon va escriure:
C'est juste dommage qu'ils n'aient pas jugé utile de rajouter dans
limits.h des définitions pour le nombre de bits des différents types.
CHAR_BIT * sizeof(t), c'est pas bon pour toi ?
Dans ce thread on veut faire des tests au niveau du préprocesseur ;-)
Chqrlie.
PS: C'est vrai que les cascades de #elif, c'est ni beau, ni exhaustif, mais
c'est quand même pas loin du but.
