Conversion d'un ensemble de booléens à un certain nombre

Question

C'est le code que je vais utiliser pour prendre un ensemble de trois booléens et le convertir en un int pour une instruction switch:

int bits = 0; 
bool a = true, b = false, c = true; // 101 = 5 

bits = bits | a << 2; 
bits = bits | b << 1; 
bits = bits | c; 

cout << bits; 

J'ai huit cas sur la base sur l'état combiné de ces trois booléens. Est-ce que je fais ça bien?

Droit, pas dans le sens de la syntaxe, mais s'il y a des problèmes, s'il vous plaît aviser. Plus juste dans le sens de "Est-ce la meilleure façon de résoudre ce problème?"

Answer 1

Si vous utilisez C++, vous pouvez utiliser bitset<N>.

Answer 2

Vous pouvez toujours faire la conversion explicitement:

bits = bits | (a ? 1 : 0) << 2; 

Cependant je crois que C/C++ se chargera implicitement, une fois que vous utilisez l'opérateur décalage de bits.

Vous devez définir des constantes pour chaque indicateur, ce qui donne un nom au bit que vous définissez:

const int a_flag = 2; 
bits = bits | (a ? 1 : 0) << a_flag; 

Edit:

Comme vous pouvez le voir sur les commentaires sur ma réponse, la plupart C Les programmeurs C++ préfèrent apprendre les conversions implicites et la priorité des opérateurs. Par conséquent, votre code d'origine est "le plus correct".

Edit 2:

Sauf, vous devez utiliser l'opérateur |=:

const int a_flag = 2; 
bits |= a << a_flag; 

Answer 3

Vous faites bien. Vous pouvez rendre le code un peu plus succinct que:

bits |= (a<<2) | (b<<1) | (c<<0); 

Soyez conscient que la norme n'impose aucune contrainte de taille sur bool. Pragmatiquement parlant, il ne devrait pas y avoir de problème avec trois bits, mais la norme ne vous soutient pas ici.

Answer 4

je le ferais comme:

bits = (bits << 1) | a; 
bits = (bits << 1) | b; 
bits = (bits << 1) | c; 

qui nécessiterait moins de travail d'entretien si vous avez besoin d'ajouter ou de supprimer un drapeau. Toutefois, faire ceci pour que vous puissiez l'utiliser pour un switch semble être une mauvaise idée. L'ajout d'un drapeau doublerait le nombre d'états que vous auriez à gérer, et les valeurs case seraient fragiles et difficiles à lire.

Mais si vous devez vraiment, voici une autre approche:

enum 
{ 
    c_bit_offset, 
    b_bit_offset, 
    a_bit_offset 
}; 

unsigned int bits = (a << a_bit_offset) 
        | (b << b_bit_offset) 
        | (c << c_bit_offset); 
switch (bits) 
{ 
    case 0: 
     /* Do something. */ 
     break; 
    case (1 << a_bit_offset): 
     /* Do something. */ 
     break; 
    case (1 << a_bit_offset) | (1 << b_bit_offset): 
     /* Do something. */ 
     break; 
    ... 
} 

Par ailleurs, vous devriez probablement utiliser unsigned int au lieu de int.

Answer 5

$ cat ttt.c

//example of C solution 
#include <stdio.h> 

int main() { 
     union { 
       unsigned int val; 
       struct { 
         unsigned a : 1; 
         unsigned b : 1; 
         unsigned c : 1; 
         //unsigned d : 1; 
         //e, f, g, h... 
       } flags; 
     } bits; 

     bits.val=0; 
     bits.flags.a = 1; 
     bits.flags.c = 1; 

     printf("val: %d\n",bits.val); 
     return 0; 
} 

~ ./ttt $

val: 5 

Answer 6

Vous pouvez faire pour faire quelques définit facile de travailler avec des morceaux

#define BitSet(arg,bit) ((arg) |= (1<<bit)) 
#define BitClr(arg,bit) ((arg) &= ~(1<<bit)) 
#define BitFlp(arg,bit) ((arg) ^= (1<<bit)) 
#define BitTst(arg,bit) ((arg) & (1<<bit)) 

Ensuite, vous pouvez utiliser un seul omble chevalier

keys = 0b00000101; 
BitSet (keys,1); 

Ceci est une façon courante de travailler dans les systèmes embarqués tems.