donné un uint16 avec un seul et un seul bit (N), je veux tester si bit_Rank a tout le jeu de bits plus significatifs. Je suis actuellement en train d'utiliser la boucle, mais je suis sûr qu'il y a un violon intelligent avec juste un couple d'opérateurs. Ce code utilise un compilateur où les opérations de bits entraînent un INT 32 bits.
uint16_t b; // loop variable
uint16_t n; // one and only one bit set
uint16_t bit_rank; // contains n and possibly higher/lower bits than n
for (b = n << 1; b < 0x10000; b <<= 1)
if (b & bit_rank)
continue;
else
break;
if (b == 0x10000)
printf("all bits from n to 0x8000 are set");
4 Réponses :
Essayez le changement de vitesse (>>) votre rang de bit par n'importe quelle position de bit en n est définie. Ensuite, vous n'avez que les bits plus importants que cette position dans le rang de bit. Ensuite, inverser (~) les bits du bit décalé droit et testez la valeur, s'il est 0, vous savez que tous les bits plus importants ont été définis. Sinon, ils n'ont pas tous été définis.
Non. Réfuté avec ce cas simple: ~ (0xFFFFFFFFF >> 1) est 0x80000000, pas 0.
Si une valeur non signée B a exactement un bit défini, puis ajoutez B à une valeur non signée x du même type, et la coulée ou la contrainte du résultat à ce type (si moins que "INT") donnera une valeur au moins égale. à B, si B ou des bits plus élevés étaient clairs, et moins que B si B et tous les bits plus élevés étaient définis.
Notez que si le type de B et X est plus petit que "non signé", l'ajout de B à X dans le boîtier "Tous les bits supérieurs" donnera un résultat trop grand pour s'adapter au type de B et X. La coulée ou la forcer du résultat au petit type produirait une valeur inférieure à B, mais sinon le résultat serait plus grand.
Beaucoup mieux que ma réponse. Tous les besoins op sont: uint16_t c = bit_rank + n; if (c
@ 4386427 Nope. Réfuté si un seul bit supérieur à N est défini.
@ 4386427 Auparavant, j'ai écrit que votre réponse était fausse, mais je me rends compte que votre solution utilise un débordement et semble assez correct. Merci. Bonne réponse.
@Bsalita semble qu'il y ait un peu de confusion ici. Cette réponse est écrite par SuperCat . Ce n'est pas écrit par moi. J'ai posté une réponse mais j'ai supprimé de nouveau parce que cette réponse est meilleure que la mienne. BTW: Si cette réponse vous a aidé, envisagez de l'accepter.
@ 4386427 Je donne du crédit au code sur des mots. Sa réponse manque de code. C'est pourquoi vous avez laissé le code dans votre commentaire. Je vous remercie tous les deux mais je préfère la réponse marquée, car c'est tout aussi bon code mais une réponse plus robuste.
Je n'ai pas accès au compilateur en ce moment, donc excuse les erreurs de compilation, Mais voici la solution que j'utilise dans les lignes générales:
Étape 1: Préparez le masque souhaité. Ceci est fait en tant que réseau de variables statiques, pour améliorer les performances (la fonction ne doit pas nécessiter d'allouer le tableau sur la pile à chaque appel). P>
Remarque: chaque entrée au masque concerne le n masque concerné dont vous avez besoin. de sorte que Masque [3] signifie les bits Fron N et ON SET. P>
if ( ( bit_rank & mask[n] ) == mask(n) )
printf( "all bits fron n and on, are set\n" );
Une autre solution simple est qui fonctionne depuis pour que quelque chose soit inférieur à n , le bit de n plus Les bits doivent être zéro, ce qui signifie bit_rank (qui par hypothèse contient le bit de n ) a toutes les bits supérieurs à celui de n défini.
On dirait votre réponse et le commentaire laissé par @ 4386427 sont également bons et intelligents. Je marquais votre réponse comme correct.
@bsalita: Si cette réponse est correcte, vous avez mal soutenu l'exigence. Considérons n == 1 et bit_rank == 0xFFFE . bit_rank a tous les bits supérieurs à n défini, mais (uint16_t) ~ bit_rank est 1, ce qui n'est pas bit_rank a N et Tous les bits d'ordre supérieur." Si tel est le cas, vous devriez corriger la question (et je supprimerai ma réponse, qui correspond à la spécification dans la question actuelle).
Le commentaire de bit_rank dans la question des états "contient des bits n et éventuellement plus élevés / inférieurs à n" que j'ai interprété pour signifier que le bit défini dans n est connu pour être aussi Définissez dans bit_rank , comme vous le suggérez.
@ Falkhüffner exactement. On doit lire complètement la question pour former la bonne réponse. Ceci est un problème fréquent sur Stackoverflow.
@ Falkhüffner: Mais ce n'est pas ce que le code fait réellement, car la boucle commence par b = n << 1 . J'ai basé ma lecture sur le texte dans la question plus le comportement du code exemple, qui sont cohérents. On pourrait également dire qu'un problème fréquent avec des questions de manière incohérente de manière incohérente.
Est-ce que ça marche? La dernière comparaison
(b == 0x10000) semble un peu méfiant pour moi ... (Pun n'est pas prévu)Je ne sais pas bien comprendre ce que vous voulez, mais n'est-ce pas
si (n & bit_rank == n) ce dont vous avez besoin?Pouvez-vous ajouter des échantillons de données avec une sortie attendue?
Faire cela ne testera pas si des bits plus significatifs que N dans le rang de bit sont définis, il ne testera que si le nième bit dans le rang bit est défini
Si b est uint16_t, alors
b <0x10000 Toujours sera vrai etb == 0x10000 est toujours faux@Caipan Les opérations effectuées sur B sont effectuées à l'aide de INT (non uint16_t). Par conséquent, le code fonctionne.
Eh bien, le code 'fonctionne', mais ... quelle est la valeur maximale pouvant apparaître dans
uint16_t b ...? Spécifiquement: quel est le bit le plus significatif qui peut éventuellement être défini dansB ?