Discussion :

[Eusebe]

Bonjour à tous,

J'aimerais avoir votre avis sur l'utilisation du type bitset pour gérer des booléens.
J'ai par exemple une classe Widget qui gère plusieurs états vis à vis de la souris (intercepte les clics de la souris gauche / droit / central, intercepte les mouvements de la souris...). J'aimerais stocker l'ensemble de ces états (booléens) dans une seule variable, en gérant des bits. En fouinant à droit à gauche, je suis finalement tombé sur la classe bitset. J'ai l'impression que c'est cette classe qu'il faut utiliser, mais je ne sais pas encore trop comment...

Voici un code qui expose ma situation actuelle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <bitset>
#include <iostream>
#include <string>
 
const std::bitset<10> HANDLE_LEFT_CLIC(std::string("0100000000"));
 
int main()
{
    std::bitset<10> A(std::string("0101010101"));
 
    if ((A & HANDLE_LEFT_CLIC) == HANDLE_LEFT_CLIC)
    {
        std::cout << "Je gère les clics gauches !" << std::endl;
    }
 
	return 0;
}

Ce code est juste là pour vérifier que mon bitset B a le deuxième bit à true... Mais je trouve ça un peu complexe pour un résultat si simple. Y aurait-il un autre moyen, plus direct, de le vérifier (toujours en utilisant une constante comme dans l'exemple) ?

Merci d'avance pour vos réponses

[Laurent Gomila]

Oui il y a beaucoup plus simple, il suffit de penser au bitset comme un tableau de bits, et oublier les masques & cie.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
enum
{
    HANDLE_LEFT_CLIC = 0,
    ...
};
 
if (A[HANDLE_LEFT_CLIC])
    ...

[Eusebe]

En effet, mais si je fais ça, je ne pourrais plus utiliser mes constantes pour faire un appel comme par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

setMouseFlags(HANDLE_LEFT_CLIC | HANDLE_RIGHT_CLIC)

[Laurent Gomila]

Non, effectivement.

Mais tu peux garder tes flags comme avant (sous forme de constante entière) ainsi qu'un simple & binaire, il me semble que bitset surcharge correctement ces opérateurs.

Enfin en même temps si tu utilises des masques l'intérêt d'un bitset est réduit à zéro, puisqu'au final tu auras exactement le même code qu'avant.

[Pragmateek]

Les bitset ne sont peut être pas assez performant, surtout pour économiser quelques octets. Des "int" seront plus efficaces.
A moins que le compilo n'optimise de lui même.

[Laurent Gomila]

Les bitset ne sont peut être pas assez performant, surtout pour économiser quelques octets. Des "int" seront plus efficaces.
A moins que le compilo n'optimise de lui même.

Les bitsets ne font ni plus ni moins que ce que tu feras avec des entiers et des opérateurs bits à bits.
Et puis il ne faut pas toujours se focaliser sur les performances, surtout à ce niveau

[Eusebe]

Mais tu peux garder tes flags comme avant (sous forme de constante entière) ainsi qu'un simple & binaire, il me semble que bitset surcharge correctement ces opérateurs.

Je ne comprend pas bien ce que tu veux dire... C'est créer deux jeux de constantes ?

Enfin en même temps si tu utilises des masques l'intérêt d'un bitset est réduit à zéro, puisqu'au final tu auras exactement le même code qu'avant.

Ben non, "avant" j'utilisais des bool... Alors ça multipliait le nombre de variables de façon très importante... c'est la première fois que j'essaie une gestion bits à bits, et c'est pour ça que je m'interroge pas mal

Les bitset ne sont peut être pas assez performant, surtout pour économiser quelques octets. Des "int" seront plus efficaces.
A moins que le compilo n'optimise de lui même.

Pour l'instant, la performance n'est pas ma priorité, et mon objectif n'est pas spécialement d'économiser quelques octets . De manière générale, je préfère un code clair et facile à maintenir à un code très optimisé.
Si j'utilise des int, le code à écrire est le même que dans mon premier post, non ? (je veux dire, à quelques chouillas prêts, je suppose que la gestion est la même ?)

En même temps, en conservant la syntaxe voulue (combinaison de bits), je ne vois pas ce qui pourrait être plus "performant".

Je ne suis pas complètement attaché à cette syntaxe
Ce que j'aimerais, c'est un moyen clair de gérer un nombre important (enfin, relativement, hein ) de booléens (aussi bien en écriture qu'en lecture)

[Laurent Gomila]

En général, pour gérer une combinaisons d'options, ce qu'on utilise et qui marche très bien en étant simple, c'est ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
enum
{
   OPTION1 = (1 << 0), // 0001
   OPTION2 = (1 << 1), // 0010
   OPTION3 = (1 << 2), // 0100
   OPTION4 = (1 << 3), // 1000
};
 
int MesOptions = OPTION1 | OPTION3; // 0101
 
if (MesOptions & OPTION3)
{
    // Option 3 présente
}

Inutile de se prendre la tête