Un peu dans un int

J'ai besoin de masquer certaines valeurs de chaîne de lire à partir d'une base de données en définissant un peu spécifique dans un int valeur pour chaque valeur de base de données. Par exemple, si la base de données renvoie la chaîne "valeur1", alors le bit en position 0, devront être mis à 1, mais si la base de données renvoie "valeur2", alors le bit en position 1 devra être mis à 1 au lieu de.

Comment puis-je m'assurer chaque bit d'un entier est mis à 0 à l'origine et puis tourner sur l de bits spécifié?

intValue |= 1 << position;
Lire sur peu sage opérateurs trop. Toujours bon à savoir
J'aime votre meilleure solution (puisque vous n'avez pas besoin de déterminer le nombre hexadécimal). Je upvote si c'était une réponse.
double possible de Comment désactiver un peu spécifique dans un entier
ne poussez pas un vieux et très sloooow homme 😉

OriginalL'auteur Michael Kingsmill | 2014-06-16

  1. 33

    Si vous avez un int valeur "intValue" et vous voulez mettre un peu spécifique à la position "bitPosition", faire quelque chose comme:

    intValue = intValue | (1 << bitPosition);

    ou moins:

    intValue |= 1 << bitPosition;


    Si vous souhaitez réinitialiser un peu (j'.e, mettre zéro), vous pouvez le faire:

    intValue &= ~(1 << bitPosition);

    (L'opérateur ~ inverse chaque bit d'une valeur, donc ~(1 << bitPosition) entraînera une int où chaque bit est 1 à l'exception de la peu à l' bitPosition.)

    Vous devez également mentionner la façon de zéro, que peu.
    merci, j'ai ajouté un exemple pour réinitialiser un peu.
    je pense que vous pouvez changer "Si vous avez un int valeur" à "Si vous avez un int valeur" 😉
    en effet 🙂

    OriginalL'auteur elgonzo

  2. 6

    À tout mettre à 0, ET la valeur 0 x 00000000:

    int startValue = initialValue & 0x00000000;
//Or much easier :)
int startValue = 0;

    Définir ensuite les bits, vous devez déterminer ce nombre a juste que peu ensemble et OU il. Par exemple, pour définir le dernier bit:

    int finalValue = startValue | 0x00000001;

    @Magus points, pour débloquer un peu, vous faites exactement le contraire:

    int finalValue = startValue & 0xFFFFFFFE;
//Or
int finalValue = startValue & ~(0x00000001);

    L' ~ operatior est not au niveau du bit qui se retourne chaque bit.

    Peut également mentionner qu'une & avec tous les 1s et un 0 va définir les bits spécifié à 0, dans le cas où c'est nécessaire.
    Bon point! Ajout de deux façons de le faire.
    Hmm, complexe de réglage à 0, n'est-ce pas?
    En effet, changé le code pour améliorer la "juste assigner à 0" option. Il ne s'illustrer de la plus tard de code meilleur (OMI).
    Tant que votre algorithme est optimisé première, qui fait sens pour moi. Sans un algorithme optimisé, des opérations bit à bit sont en quelque sorte inutile.

    OriginalL'auteur BradleyDotNET