enum toto {A4, BQ} t;
peut-on écrire
t(;
(cela pourrait poser problème si l'on considère que les valeurs prises
par une variable de type enum toto sont parmi 34 et 51,
enum toto {A4, BQ} t;
peut-on écrire
t(;
(cela pourrait poser problème si l'on considère que les valeurs prises
par une variable de type enum toto sont parmi 34 et 51,
enum toto {A4, BQ} t;
peut-on écrire
t(;
(cela pourrait poser problème si l'on considère que les valeurs prises
par une variable de type enum toto sont parmi 34 et 51,
enum toto {A4, BQ} t;
peut-on écrire
t(;
Bonaventure Pochard :Je cherche un bon jeu de poker pour PC ( de préférence gratuit). Que me
conseillez-vous ?
Bon sang Pochard, qu'est ce que vous avez encore inventé comme AAD ?
enum toto {A4, BQ} t;
peut-on écrire
t(;
Bonaventure Pochard :
Je cherche un bon jeu de poker pour PC ( de préférence gratuit). Que me
conseillez-vous ?
Bon sang Pochard, qu'est ce que vous avez encore inventé comme AAD ?
enum toto {A4, BQ} t;
peut-on écrire
t(;
Bonaventure Pochard :Je cherche un bon jeu de poker pour PC ( de préférence gratuit). Que me
conseillez-vous ?
Bon sang Pochard, qu'est ce que vous avez encore inventé comme AAD ?
Bonjour,
La norme C90 dit
--------------------------- 8< ------------------------------------
Each enumerated type shall be compatible with an integer type; the
choice of type is implementation-defined.
--------------------------- >8 ------------------------------------
Ce qui n'est pas très clair c'est que par ailleurs :
--------------------------- 8< ------------------------------------
An identifier declared as an enumeration constant has type int.
--------------------------- >8 ------------------------------------
Je me pose donc la question de savoir si on peut utiliser sans risque
une variable de type énumération exactement comme s'il s'agissait d'une
variable de type int ? Je dis "sans risque" parce que formellement, je
crois que rien ne m'en empêche :
--------------------------- 8< ------------------------------------
A char, a short int, or an int bit-field, or their signed or
unsigned varieties, or an object that has enumeration type, may be
used in an expression wherever an int or unsigned int may be used.
--------------------------- >8 ------------------------------------
Si, par exemple
enum toto {A4, BQ} t;
peut-on écrire
t(;
(cela pourrait poser problème si l'on considère que les valeurs prises
par une variable de type enum toto sont parmi 34 et 51, cf. ma première
citation de la norme) ? Bon, en fait j'imagine que ça ne pose pas de
problème particulier mais je trouve que la norme n'est pas formelle sur
ce point. Par contre, pourrait-il y avoir des problèmes si on écrivait
t=-5;
?
Quelles précautions particulières prendre avec des variables de type
énumération ? Harbison & Steele recommandent une certaine prudence :
--------------------------- 8< ------------------------------------
We suggest that programmers treat enumerated types as different from
integers and not mix them in integer expressions without using casts.
--------------------------- >8 ------------------------------------
mais ils ne donnent aucun exemple illustrant les précautions à prendre.
Concrètement faut faire quoi ? Ainsi dans mon premier exemple ci-dessus,
dois-je écrire
t=(enum toto) 28;
?
Merci.
Bonjour,
La norme C90 dit
--------------------------- 8< ------------------------------------
Each enumerated type shall be compatible with an integer type; the
choice of type is implementation-defined.
--------------------------- >8 ------------------------------------
Ce qui n'est pas très clair c'est que par ailleurs :
--------------------------- 8< ------------------------------------
An identifier declared as an enumeration constant has type int.
--------------------------- >8 ------------------------------------
Je me pose donc la question de savoir si on peut utiliser sans risque
une variable de type énumération exactement comme s'il s'agissait d'une
variable de type int ? Je dis "sans risque" parce que formellement, je
crois que rien ne m'en empêche :
--------------------------- 8< ------------------------------------
A char, a short int, or an int bit-field, or their signed or
unsigned varieties, or an object that has enumeration type, may be
used in an expression wherever an int or unsigned int may be used.
--------------------------- >8 ------------------------------------
Si, par exemple
enum toto {A4, BQ} t;
peut-on écrire
t(;
(cela pourrait poser problème si l'on considère que les valeurs prises
par une variable de type enum toto sont parmi 34 et 51, cf. ma première
citation de la norme) ? Bon, en fait j'imagine que ça ne pose pas de
problème particulier mais je trouve que la norme n'est pas formelle sur
ce point. Par contre, pourrait-il y avoir des problèmes si on écrivait
t=-5;
?
Quelles précautions particulières prendre avec des variables de type
énumération ? Harbison & Steele recommandent une certaine prudence :
--------------------------- 8< ------------------------------------
We suggest that programmers treat enumerated types as different from
integers and not mix them in integer expressions without using casts.
--------------------------- >8 ------------------------------------
mais ils ne donnent aucun exemple illustrant les précautions à prendre.
Concrètement faut faire quoi ? Ainsi dans mon premier exemple ci-dessus,
dois-je écrire
t=(enum toto) 28;
?
Merci.
Bonjour,
La norme C90 dit
--------------------------- 8< ------------------------------------
Each enumerated type shall be compatible with an integer type; the
choice of type is implementation-defined.
--------------------------- >8 ------------------------------------
Ce qui n'est pas très clair c'est que par ailleurs :
--------------------------- 8< ------------------------------------
An identifier declared as an enumeration constant has type int.
--------------------------- >8 ------------------------------------
Je me pose donc la question de savoir si on peut utiliser sans risque
une variable de type énumération exactement comme s'il s'agissait d'une
variable de type int ? Je dis "sans risque" parce que formellement, je
crois que rien ne m'en empêche :
--------------------------- 8< ------------------------------------
A char, a short int, or an int bit-field, or their signed or
unsigned varieties, or an object that has enumeration type, may be
used in an expression wherever an int or unsigned int may be used.
--------------------------- >8 ------------------------------------
Si, par exemple
enum toto {A4, BQ} t;
peut-on écrire
t(;
(cela pourrait poser problème si l'on considère que les valeurs prises
par une variable de type enum toto sont parmi 34 et 51, cf. ma première
citation de la norme) ? Bon, en fait j'imagine que ça ne pose pas de
problème particulier mais je trouve que la norme n'est pas formelle sur
ce point. Par contre, pourrait-il y avoir des problèmes si on écrivait
t=-5;
?
Quelles précautions particulières prendre avec des variables de type
énumération ? Harbison & Steele recommandent une certaine prudence :
--------------------------- 8< ------------------------------------
We suggest that programmers treat enumerated types as different from
integers and not mix them in integer expressions without using casts.
--------------------------- >8 ------------------------------------
mais ils ne donnent aucun exemple illustrant les précautions à prendre.
Concrètement faut faire quoi ? Ainsi dans mon premier exemple ci-dessus,
dois-je écrire
t=(enum toto) 28;
?
Merci.
pertinente et doit être suivie. De toute façon, le livre d'Harbison &
Steele est, à mon avis, le meilleur livre sur C.
Pourquoi vouloir à tout prix "utiliser une variable de type enum
exactement comme une variable de type int" ?
Ou tes questions ne sont-elles là que pour illustrer que la norme n'est
pas très clair sur la frontière enum/int ?
pertinente et doit être suivie. De toute façon, le livre d'Harbison &
Steele est, à mon avis, le meilleur livre sur C.
Pourquoi vouloir à tout prix "utiliser une variable de type enum
exactement comme une variable de type int" ?
Ou tes questions ne sont-elles là que pour illustrer que la norme n'est
pas très clair sur la frontière enum/int ?
pertinente et doit être suivie. De toute façon, le livre d'Harbison &
Steele est, à mon avis, le meilleur livre sur C.
Pourquoi vouloir à tout prix "utiliser une variable de type enum
exactement comme une variable de type int" ?
Ou tes questions ne sont-elles là que pour illustrer que la norme n'est
pas très clair sur la frontière enum/int ?
Wykaaa a écrit :pertinente et doit être suivie. De toute façon, le livre d'Harbison &
Steele est, à mon avis, le meilleur livre sur C.
Voilà donc qui n'est pas très flatteur pour la littérature sur le C.
Wykaaa a écrit :
pertinente et doit être suivie. De toute façon, le livre d'Harbison &
Steele est, à mon avis, le meilleur livre sur C.
Voilà donc qui n'est pas très flatteur pour la littérature sur le C.
Wykaaa a écrit :pertinente et doit être suivie. De toute façon, le livre d'Harbison &
Steele est, à mon avis, le meilleur livre sur C.
Voilà donc qui n'est pas très flatteur pour la littérature sur le C.
Ou alors,
tu n'aimes pas Harbison & Steele ?
Manque de bol, sur un axe tres precis, c'est effectivement un des meilleurs
bouquins existants: c'est un tres bon ouvrage de reference vis-a-vis du
langage. Forcement moins exact que la norme, par construction, mais egalement
sensiblement plus digeste.
Je ne l'ai jamais pris en defaut jusqu'ici.
Par contre, ca n'est clairement pas un bouquin d'apprentissage du C.
Mais, sur ce plan, je ne sais pas s'il existe grand chose de correct en
dehors du K&R (qui est fort bien, mais quelque peu limite parfois)...
les autres bouquins auxquels j'ai jete un oeil sont le plus souvent
largement pires (en particulier, remplis d'erreurs et d'inexactitudes).
Ou alors,
tu n'aimes pas Harbison & Steele ?
Manque de bol, sur un axe tres precis, c'est effectivement un des meilleurs
bouquins existants: c'est un tres bon ouvrage de reference vis-a-vis du
langage. Forcement moins exact que la norme, par construction, mais egalement
sensiblement plus digeste.
Je ne l'ai jamais pris en defaut jusqu'ici.
Par contre, ca n'est clairement pas un bouquin d'apprentissage du C.
Mais, sur ce plan, je ne sais pas s'il existe grand chose de correct en
dehors du K&R (qui est fort bien, mais quelque peu limite parfois)...
les autres bouquins auxquels j'ai jete un oeil sont le plus souvent
largement pires (en particulier, remplis d'erreurs et d'inexactitudes).
Ou alors,
tu n'aimes pas Harbison & Steele ?
Manque de bol, sur un axe tres precis, c'est effectivement un des meilleurs
bouquins existants: c'est un tres bon ouvrage de reference vis-a-vis du
langage. Forcement moins exact que la norme, par construction, mais egalement
sensiblement plus digeste.
Je ne l'ai jamais pris en defaut jusqu'ici.
Par contre, ca n'est clairement pas un bouquin d'apprentissage du C.
Mais, sur ce plan, je ne sais pas s'il existe grand chose de correct en
dehors du K&R (qui est fort bien, mais quelque peu limite parfois)...
les autres bouquins auxquels j'ai jete un oeil sont le plus souvent
largement pires (en particulier, remplis d'erreurs et d'inexactitudes).
Hélas, il n'existe aucun bouquin ni même document décent sur le C (j'en
ai consulté ou lu des dizaines) mais il existe une multiplicité de
références plus ou moins correctes sur tel ou tel point plus ou moins
important. C'est pas compliqué tu prends une à une les questions plus ou
moins basiques sur le C qu'on lisait sur fclc il y a quelques années ou
encore maintenant sur clc voire sur csc et tu dois te rendre compte que
la réponse n'est dans aucun document figé. Pourtant, ces questions
répondent à un savoir figé (le C est une langue morte bien que toujours
parlé et étudié) et est connu de nombreuses personnes. Bien sûr, ce que
je te dis là vaut de beaucoup d'autres choses, en particulier tout ce
qui touche à l'utilisation d'outils informatiques où le savoir ne passe
pas par la documentation à moins d'être du sérail. Faut pas s'étonner
des succès de sites du genre le siteduzéro.
Hélas, il n'existe aucun bouquin ni même document décent sur le C (j'en
ai consulté ou lu des dizaines) mais il existe une multiplicité de
références plus ou moins correctes sur tel ou tel point plus ou moins
important. C'est pas compliqué tu prends une à une les questions plus ou
moins basiques sur le C qu'on lisait sur fclc il y a quelques années ou
encore maintenant sur clc voire sur csc et tu dois te rendre compte que
la réponse n'est dans aucun document figé. Pourtant, ces questions
répondent à un savoir figé (le C est une langue morte bien que toujours
parlé et étudié) et est connu de nombreuses personnes. Bien sûr, ce que
je te dis là vaut de beaucoup d'autres choses, en particulier tout ce
qui touche à l'utilisation d'outils informatiques où le savoir ne passe
pas par la documentation à moins d'être du sérail. Faut pas s'étonner
des succès de sites du genre le siteduzéro.
Hélas, il n'existe aucun bouquin ni même document décent sur le C (j'en
ai consulté ou lu des dizaines) mais il existe une multiplicité de
références plus ou moins correctes sur tel ou tel point plus ou moins
important. C'est pas compliqué tu prends une à une les questions plus ou
moins basiques sur le C qu'on lisait sur fclc il y a quelques années ou
encore maintenant sur clc voire sur csc et tu dois te rendre compte que
la réponse n'est dans aucun document figé. Pourtant, ces questions
répondent à un savoir figé (le C est une langue morte bien que toujours
parlé et étudié) et est connu de nombreuses personnes. Bien sûr, ce que
je te dis là vaut de beaucoup d'autres choses, en particulier tout ce
qui touche à l'utilisation d'outils informatiques où le savoir ne passe
pas par la documentation à moins d'être du sérail. Faut pas s'étonner
des succès de sites du genre le siteduzéro.
Les gens qui programment en C pour de vrai, dont je fais partie, ont
une tendance tres nette a NE PAS utiliser les bouts du langage les moins
clairs et les plus vicieux.
Si ce sont des morceaux pour lesquels il est
difficile de trouver des reponses, il y a de tres fortes chances
qu'une
part non negligeable des implementations soient fausses...
Typiquement, tes questions recentes sur les enum. Les points un peu
bizarres de typage des enums font qu'une enum est tres rarement une bonne
idee, et qu'en tout cas il vaut mieux ne pas dependre des points obscurs
de la norme.
Les gens qui programment en C pour de vrai, dont je fais partie, ont
une tendance tres nette a NE PAS utiliser les bouts du langage les moins
clairs et les plus vicieux.
Si ce sont des morceaux pour lesquels il est
difficile de trouver des reponses, il y a de tres fortes chances
qu'une
part non negligeable des implementations soient fausses...
Typiquement, tes questions recentes sur les enum. Les points un peu
bizarres de typage des enums font qu'une enum est tres rarement une bonne
idee, et qu'en tout cas il vaut mieux ne pas dependre des points obscurs
de la norme.
Les gens qui programment en C pour de vrai, dont je fais partie, ont
une tendance tres nette a NE PAS utiliser les bouts du langage les moins
clairs et les plus vicieux.
Si ce sont des morceaux pour lesquels il est
difficile de trouver des reponses, il y a de tres fortes chances
qu'une
part non negligeable des implementations soient fausses...
Typiquement, tes questions recentes sur les enum. Les points un peu
bizarres de typage des enums font qu'une enum est tres rarement une bonne
idee, et qu'en tout cas il vaut mieux ne pas dependre des points obscurs
de la norme.
Par ailleurs, je précise que Kernighan et Pike recommandent dans "The
Pratice of Programming" (page 20) :
---------------- 8< ----------------------
[...]In C and C++, integer constants can be defined with an enum
statement
[...] so the enum statement
------------------ >8 ---------------------
Par ailleurs, je précise que Kernighan et Pike recommandent dans "The
Pratice of Programming" (page 20) :
---------------- 8< ----------------------
[...]In C and C++, integer constants can be defined with an enum
statement
[...] so the enum statement
------------------ >8 ---------------------
Par ailleurs, je précise que Kernighan et Pike recommandent dans "The
Pratice of Programming" (page 20) :
---------------- 8< ----------------------
[...]In C and C++, integer constants can be defined with an enum
statement
[...] so the enum statement
------------------ >8 ---------------------
Wykaaa a écrit :pertinente et doit être suivie. De toute façon, le livre d'Harbison &
Steele est, à mon avis, le meilleur livre sur C.
Voilà donc qui n'est pas très flatteur pour la littérature sur le C.
Pourquoi vouloir à tout prix "utiliser une variable de type enum
exactement comme une variable de type int" ?
Ou tes questions ne sont-elles là que pour illustrer que la norme
n'est pas très clair sur la frontière enum/int ?
Je voulais éclaicir les conséquences de ce que dit la norme et aussi
connaître la façon reconnue d'utiliser des variables de type enum.
Wykaaa a écrit :
pertinente et doit être suivie. De toute façon, le livre d'Harbison &
Steele est, à mon avis, le meilleur livre sur C.
Voilà donc qui n'est pas très flatteur pour la littérature sur le C.
Pourquoi vouloir à tout prix "utiliser une variable de type enum
exactement comme une variable de type int" ?
Ou tes questions ne sont-elles là que pour illustrer que la norme
n'est pas très clair sur la frontière enum/int ?
Je voulais éclaicir les conséquences de ce que dit la norme et aussi
connaître la façon reconnue d'utiliser des variables de type enum.
Wykaaa a écrit :pertinente et doit être suivie. De toute façon, le livre d'Harbison &
Steele est, à mon avis, le meilleur livre sur C.
Voilà donc qui n'est pas très flatteur pour la littérature sur le C.
Pourquoi vouloir à tout prix "utiliser une variable de type enum
exactement comme une variable de type int" ?
Ou tes questions ne sont-elles là que pour illustrer que la norme
n'est pas très clair sur la frontière enum/int ?
Je voulais éclaicir les conséquences de ce que dit la norme et aussi
connaître la façon reconnue d'utiliser des variables de type enum.