La vérification conditionnelle de “i == (2 ^ 8)” échoue quand i est 512?

Voici un petit programme pour imprimer des puissances allant de 2 à 8 heures.

#include  #include  int main(void) { unsigned int i=1; while(1) { i = i<<1; printf("i = %d\n",i); if(i==(2^8)) break; sleep(1); } printf("Exited While loop.. \n"); return 0; } 

La boucle ne se termine pas lorsque i = 2 ^ 8. Ma sortie ressemble à ceci:

 i = 2 i = 4 i = 8 i = 16 i = 32 i = 64 i = 128 i = 256 i = 512 (Should have Exited here. But the program is continuing. Why?) i = 1024 i = 2048 i = 4096.... 

MODIFIER :

Merci d’avoir répondu que ^ est un opérateur XOR. Mais maintenant, le code ci-dessous se comporte de manière étrange. S’il vous plaît, expliquez.

 #include  int main(void) { if((2)^8 == 1<<8) { printf("True.. \n"); } else { printf("False..!!"); } return 0; } 

Le programme de fonction ci-dessus imprime vrai.

En C, l’opérateur ^ signifie XOR (bitwise exclusif or).

Pour obtenir 2 à la puissance de 8, vous devez utiliser une boucle (res * = 2 dans une boucle) ou contourner la fonction pow dans math.h (notez que la fonction math.h renvoie float – et a donc gagné ». t être égal à l’entier).

La méthode la plus simple est bien sûr le décalage au niveau du bit.

À propos de la section d’édition:

Bienvenue dans le monde merveilleux de la priorité des opérateurs . Ce qui se passe, c’est que == a une priorité supérieure à ^, et donc le conditionnel s’évalue à 2 ^ 0, ce qui correspond à 2, ce qui est vrai.

Pour que cela fonctionne, vous devez append des parenthèses:

 if ( (2^8) == (1<<8) ) ... 

Le problème est que ^ est l’opérateur Bitwise XOR , et non pas le pouvoir. Expliquons 2^8 au format bitwise:

 2 = 0010 8 = 1000 ======== xor 10= 1010 

de sorte que le résultat, en appliquant xor au fur et à mesure, est 10, cela ne se produit jamais et votre boucle ne se termine jamais. Vous pouvez faire fonctionner votre test unitaire si vous utilisez pow(2,8) et arrondir à l’entier à la place.

Une autre information, ce n’est probablement pas le cas dans cet exemple, mais il est préférable d’éviter la ssortingcte égalité lorsqu’on travaille avec des valeurs à virgule flottante, la comparaison avec un epsilon est préférable.

Pour votre édition: Assurez la priorité avec ceci:

 if((2^8) == (1<<8)) 

cela retournera faux, comme prévu.

2^8 est 2 XOR 8 , c’est-à-dire. 10, pas 256. Votre boucle ne s’arrête donc pas. Vous voudrez probablement vérifier contre (1<<8) ou 256 spécifiquement.

^ n’est pas le pouvoir en c, cela signifie XOR . 2 ^ 8 == 10 et il ne sera pas égal à i dans ce code.

^ est bitwise XOR, la fonction que vous recherchez est pow in math.h 🙂

Pour votre section d’édition

 #include  int main() { if((2^8) == (1<<8)) { printf("True.. \n"); } else { printf("False..!!"); } return 0; } 

Il retournera Faux .