IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Utilisation de bitset pour gérer un ensemble de booléen


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre Expert
    Avatar de Eusebe
    Inscrit en
    Mars 2006
    Messages
    1 992
    Détails du profil
    Informations personnelles :
    Âge : 47

    Informations forums :
    Inscription : Mars 2006
    Messages : 1 992
    Par défaut Utilisation de bitset pour gérer un ensemble de booléen
    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

  2. #2
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    Avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2003
    Messages : 10 651
    Par défaut
    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])
        ...

  3. #3
    Membre Expert
    Avatar de Eusebe
    Inscrit en
    Mars 2006
    Messages
    1 992
    Détails du profil
    Informations personnelles :
    Âge : 47

    Informations forums :
    Inscription : Mars 2006
    Messages : 1 992
    Par défaut
    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)

  4. #4
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    Avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2003
    Messages : 10 651
    Par défaut
    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.

  5. #5
    Membre Expert
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    Mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : Mars 2006
    Messages : 2 635
    Par défaut
    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.

  6. #6
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    Avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2003
    Messages : 10 651
    Par défaut
    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

  7. #7
    Membre Expert
    Avatar de Eusebe
    Inscrit en
    Mars 2006
    Messages
    1 992
    Détails du profil
    Informations personnelles :
    Âge : 47

    Informations forums :
    Inscription : Mars 2006
    Messages : 1 992
    Par défaut
    Citation Envoyé par Laurent Gomila
    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 ?

    Citation Envoyé par Laurent Gomila
    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

    Citation Envoyé par seriousme
    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 ?)

    Citation Envoyé par seriousme
    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)

  8. #8
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    Avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2003
    Messages : 10 651
    Par défaut
    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

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 3
    Dernier message: 03/09/2013, 13h40
  2. [Composite] Utiliser ce pattern pour gérer un planning ?
    Par spike2 dans le forum Design Patterns
    Réponses: 0
    Dernier message: 30/01/2012, 10h37
  3. [SAX] Utilisation de LexicalHandler pour gérer les données CDATA en base 64
    Par tdeco dans le forum Format d'échange (XML, JSON...)
    Réponses: 1
    Dernier message: 23/08/2007, 21h58
  4. Utilisation de classes pour gérer une table
    Par mathias dans le forum Access
    Réponses: 11
    Dernier message: 30/08/2006, 16h57
  5. [PDO] Utiliser l'Objet de PHP pour gérer sa base de données
    Par Viau dans le forum PHP & Base de données
    Réponses: 3
    Dernier message: 25/01/2006, 18h16

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo