Je suis récemment rencontré des fonctions où vous pouvez passer plusieurs énumes comme ceci: Puisque je pense que c'est une façon très élégante que j'ai essayé de mettre en œuvre quelque chose comme ça moi-même: maintenant si j'essaie d'appeler la fonction avec un | Deuxièmement, je veux que les deux cas de commutation soient appelés. Je ne suis pas vraiment bon avec les opérateurs binaires, je ne sais donc pas vraiment quoi faire. Toute idée serait géniale! merci!
5 Réponses :
Vous devez diviser les "jetons" possibles (non-chevauchement du cours ... Utilisez la puissance de 2):
if (_a & One) { ... }
Vous ferez mieux de le faire avec un ensemble de déclarations si ...
Ie édition: vous pouvez aussi le faire dans une instruction de commutation mais elle serait un cauchemar. Vous avez besoin de quelque chose comme celui-ci son sain d'origine pour seulement 2 options, mais une fois que vous obtenez plus que cela commence au ballon hors de contrôle. Si vous disposez de 32 options, vous auriez une instruction de commutation qui serait peu susceptible de s'adapter à n'importe quelle machine. Tout dans la solution "si" est beaucoup plus propre et bien plus sain d'esprit :)
Merci, vous avez raison, j'utilise si des déclarations maintenant et cela fonctionne comme un charme!
généralement des arguments combinés de cette manière sont des indicateurs (une valeur avec un seul jeu de bits) avec une valeur décimale de 1, 2, 4, 8, etc. en supposant que l'une et deux suivent cette règle, vous ne pouvez pas utiliser un commutateur. vérifier pour les deux. Commutateurs seulement suivez un chemin. Votre argument combiné ne correspond pas à un ou deux, mais une combinaison d'entre eux (1 | 2 == 3). Vous pouvez vérifier si un ou deux est défini comme celui-ci:
if (_a & One)
{
}
if (_a & Two)
{
}
Pour cela, vous devez faire des énumes comme: i.e. La valeur de l'élément Enum doit être en puissance de 2 pour sélectionner un boîtier valide ou si une instruction. P> Ainsi, lorsque vous le faites: P> void foo( int state) {
if ( state & STATE_A ) {
// do something
}
if ( state & STATE_B ) {
// do something
}
if ( state & STATE_C ) {
// do something
}
}
int main() {
foo( STATE_A | STATE_B | STATE_C);
}
Encore mieux, utilisez Enum State {star_a = 1 << 0, stat_b = 1 << 1, state_c = 1 << 2}; - Je trouve cela beaucoup plus explicite.
Ils ne seraient pas des États à la manière. Les états sont censés être exclusifs. Ils sont plus susceptibles d'être des drapeaux (où les drapeaux individuels sont indépendants les uns des autres).
Les opérateurs bitwises se comportent bien uniquement avec des pouvoirs de 2: Si vous essayez de faire de même avec des nombres arbitraires, vous obtiendrez des résultats inattendus: P> 0101 // 5
| 1100 // 12
------
1101 // 13
Postez votre
Enum Définition .. Vous souvenez-vous de leur faire tous les pouvoirs de 2?Remarque Le nom _A est réservé à la mise en œuvre C ++, à moins que ce ne soit le nom d'un membre de classe.