Je suis en train de coder une petite biblioth=E8que pour g=E9rer des
streams au format .kin (kinemages). Il s'agit d'un format de fichier
destin=E9 =E0 la description d'objets 3D simples tels que les segments
les triangles, etc.
J'aimerai pouvoir g=E9rer un mode d'affichage (fil de fer / plein /
points / ...) sur mes streams, et tant qu'=E0 faire, autoriser un choix
multiple. Me sentant malin, dans ma classe kin_stream je d=E9finis donc
un
Si mes souvenirs sont bons, C garantit que pour une variable enum il
sera donn=E9 assez de place pour stocker une valeur enti=E8re de la
taille de la puissance de 2 sup=E9rieure =E0 la plus grande valeur
stock=E9e dans l'enum. Les op=E9rateurs | et & sont en outre valides...
Or en C++ le compilo me cherche des noises parce que enum n'appr=E9cie
plus ces op=E9rateur... de fait, je suis oblig=E9 de caster explicitement
mes expressions :
(mode_type)(GRID | PLAIN)
[*]
Ce qui me semble enlever un peu de souplesse en ce sens que j'aimerai
donner acc=E8s uniquement aux constantes (GRID,PLAIN,...) et que leur
type ne devrait pas =E0 etre connu de l'utilisateur.
Que faire ? utiliser des defines ? ecrire une classe mod_type dans
laquelle d=E9finir les operateurs logiques ? C'est y pas un peu trop
bourrin ?
[*](j'ai cru comprendre qu'en C++ on est plus sens=E9 faire ce genre de
casts =E0 la C, qu'il y avait 4 operateur de cast =E0 utiliser en place
de cela... Mais je n'ai pas encore pris le temps de me plonger dans ces
subtilit=E9.)
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
kanze
meow wrote:
Je suis en train de coder une petite bibliothèque pour gérer des streams au format .kin (kinemages). Il s'agit d'un format de fichier destiné à la description d'objets 3D simples tels que les segments les triangles, etc.
J'aimerai pouvoir gérer un mode d'affichage (fil de fer / plein / points / ...) sur mes streams, et tant qu'à faire, autoriser un choix multiple. Me sentant malin, dans ma classe kin_stream je définis donc un
Si mes souvenirs sont bons, C garantit que pour une variable enum il sera donné assez de place pour stocker une valeur entière de la taille de la puissance de 2 supérieure à la plus grande valeur stockée dans l'enum.
Oui.
Les opérateurs | et & sont en outre valides...
Non. Ou plutôt, ils sont valides parce qu'il y a une promotion en int.
Or en C++ le compilo me cherche des noises parce que enum n'apprécie plus ces opérateur... de fait, je suis obligé de caster explicitement mes expressions :
(mode_type)(GRID | PLAIN)
Tout à fait. Le résultat de GRID | PLAIN a le type int, et il n'y a pas de conversion implicite d'in en un enum.
Ce qui me semble enlever un peu de souplesse en ce sens que j'aimerai donner accès uniquement aux constantes (GRID,PLAIN,...) et que leur type ne devrait pas à etre connu de l'utilisateur.
Que faire ? utiliser des defines ? ecrire une classe mod_type dans laquelle définir les operateurs logiques ? C'est y pas un peu trop bourrin ?
[*](j'ai cru comprendre qu'en C++ on est plus sensé faire ce genre de casts à la C, qu'il y avait 4 operateur de cast à utiliser en place de cela... Mais je n'ai pas encore pris le temps de me plonger dans ces subtilité.)
C'est une question de style. Pour des conversions de pointeur ou de référence, oui ; je dirais que les nouveaux casts s'imposent. Ici, en revanche, c'est vraiment une question de goût.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
meow wrote:
Je suis en train de coder une petite bibliothèque pour
gérer des streams au format .kin (kinemages). Il s'agit d'un
format de fichier destiné à la description d'objets 3D simples
tels que les segments les triangles, etc.
J'aimerai pouvoir gérer un mode d'affichage (fil de fer /
plein / points / ...) sur mes streams, et tant qu'à faire,
autoriser un choix multiple. Me sentant malin, dans ma classe
kin_stream je définis donc un
Si mes souvenirs sont bons, C garantit que pour une variable
enum il sera donné assez de place pour stocker une valeur
entière de la taille de la puissance de 2 supérieure à la plus
grande valeur stockée dans l'enum.
Oui.
Les opérateurs | et & sont en outre valides...
Non. Ou plutôt, ils sont valides parce qu'il y a une promotion
en int.
Or en C++ le compilo me cherche des noises parce que enum
n'apprécie plus ces opérateur... de fait, je suis obligé de
caster explicitement mes expressions :
(mode_type)(GRID | PLAIN)
Tout à fait. Le résultat de GRID | PLAIN a le type int, et il
n'y a pas de conversion implicite d'in en un enum.
Ce qui me semble enlever un peu de souplesse en ce sens que
j'aimerai donner accès uniquement aux constantes
(GRID,PLAIN,...) et que leur type ne devrait pas à etre connu
de l'utilisateur.
Que faire ? utiliser des defines ? ecrire une classe mod_type
dans laquelle définir les operateurs logiques ? C'est y pas un
peu trop bourrin ?
[*](j'ai cru comprendre qu'en C++ on est plus sensé faire ce
genre de casts à la C, qu'il y avait 4 operateur de cast à
utiliser en place de cela... Mais je n'ai pas encore pris le
temps de me plonger dans ces subtilité.)
C'est une question de style. Pour des conversions de pointeur ou
de référence, oui ; je dirais que les nouveaux casts s'imposent.
Ici, en revanche, c'est vraiment une question de goût.
--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Je suis en train de coder une petite bibliothèque pour gérer des streams au format .kin (kinemages). Il s'agit d'un format de fichier destiné à la description d'objets 3D simples tels que les segments les triangles, etc.
J'aimerai pouvoir gérer un mode d'affichage (fil de fer / plein / points / ...) sur mes streams, et tant qu'à faire, autoriser un choix multiple. Me sentant malin, dans ma classe kin_stream je définis donc un
Si mes souvenirs sont bons, C garantit que pour une variable enum il sera donné assez de place pour stocker une valeur entière de la taille de la puissance de 2 supérieure à la plus grande valeur stockée dans l'enum.
Oui.
Les opérateurs | et & sont en outre valides...
Non. Ou plutôt, ils sont valides parce qu'il y a une promotion en int.
Or en C++ le compilo me cherche des noises parce que enum n'apprécie plus ces opérateur... de fait, je suis obligé de caster explicitement mes expressions :
(mode_type)(GRID | PLAIN)
Tout à fait. Le résultat de GRID | PLAIN a le type int, et il n'y a pas de conversion implicite d'in en un enum.
Ce qui me semble enlever un peu de souplesse en ce sens que j'aimerai donner accès uniquement aux constantes (GRID,PLAIN,...) et que leur type ne devrait pas à etre connu de l'utilisateur.
Que faire ? utiliser des defines ? ecrire une classe mod_type dans laquelle définir les operateurs logiques ? C'est y pas un peu trop bourrin ?
[*](j'ai cru comprendre qu'en C++ on est plus sensé faire ce genre de casts à la C, qu'il y avait 4 operateur de cast à utiliser en place de cela... Mais je n'ai pas encore pris le temps de me plonger dans ces subtilité.)
C'est une question de style. Pour des conversions de pointeur ou de référence, oui ; je dirais que les nouveaux casts s'imposent. Ici, en revanche, c'est vraiment une question de goût.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
meow
Ok... En meme temps c'est vrai que ça semble évident une fois ennoncé. Merci.
Ok... En meme temps c'est vrai que ça semble évident une fois
ennoncé.
Merci.
