J'ai utilisé le célibataire ampersand (&) en C # pour signifier "Vérifiez la déclaration Mais ce qui suit semble être une signification et tout à fait, peut-on expliquer comment i & 1 fonctionne dans l'exemple suivant?
6 Réponses :
Bitwise et opérateur.
ici :
Le
et opérateur unaire renvoie l'adresse de son opérande (nécessitedangereux contexte).binaire
& opérateurs sont prédéfinis pour les types intégraux et BOOL. Pour des types intégrés,& calcule le logiqueet de ses opérandes. Pour bool opérands,& calcule le logiqueet de ses opérandes; c'est-à-dire que le résultat est vrai si et seulement si ses deux opérandes sont vraies.Le
& opérateur évalue les deux opérateurs indépendamment de la valeur de première.
Pour les types booléens, ce que vous avez mentionné, c'est comment il se comporte.
Pour les types entier, c'est l'opérateur "et" ".
Il peut être surchargé pour d'autres types.
Fondamentalement, l'expression (i & 1) == 0 vérifie si le bit le moins significatif de i est défini, ce qui ne se produit que si le numéro est impair .
L'ampersand représente un peu et une opération. Un opérateur bitwise renvoie le résultat d'une comparaison entre chaque bit correspondant dans les deux opérandes.
Par exemple, si X est 0110 et Y est 1010, alors un peu et des x et y (x & y) entraîne 0010.
Un seul & est "Bitwise et Opérateur", tout comme Dove a déclaré. Je regarde la deuxième partie de la question: "Pourquoi cela fonctionne-t-il?"
penser en binaire: Remarque Tous les numéros pars se termine avec 0; Donc, si le dernier bit Bitwise vérifie contre 1 retourner zéro (ce qui signifie "ne correspond pas"), c'est un nombre pair;
En C ++, vous pouvez utiliser et avec des valeurs de bool car un bool jette automatiquement à zéro ou à un (et à l'arrière) - une fois que vous optimisez les couts, vous êtes laissé avec quelque chose d'équivalent à && mais sans le Évaluation de court-circuit (vous garantissez donc que les effets secondaires de la bonne subexpression se produisent). Je suppose que cela s'applique en C # et Java, mais je ne me souviens pas de votre guichet automatique.
@Steve: Selon la question de l'OP, ils savent déjà que ce comportement existe comme un moyen de ne pas une logique booléenne à court-circuit.
@Jeff - mais il ne savait pas ce que l'opérateur était, je ne savais donc pas pourquoi cela a fonctionné pour cela. Il suffit d'essayer de relier les connaissances existantes à la nouvelle, clarifiant que le comportement de Bool Edward sait tomber hors du comportement des bits que vous avez expliqués et le comportement de moulage BOOL <-> Int.
réponses précédentes ne sont pas vraies, mais ne traitent pas comment Comme on l'a dit, Autrement dit, il y a deux différences fondamentales entre Voilà pourquoi nous avons presque toujours utiliser & diffère de && , que je pensais était votre question initiale, donc je vais prendre ça.
& est Bitwise ET. && est un ET logique. & effectue une opération ET sur ses opérandes bit par bit, et dans les fonctions générales exactement comme + ou * ou tout opérateur arithmétique. && est plus complexe. Il compare chacun de ses opérandes contre zéro. Si le premier opérande est égal à zéro, il prend la valeur false et court-circuite le reste de l'expression, à savoir qu'il n'évalue les opérandes restants. Si la première valeur est non nulle, il examine la deuxième valeur. Si cela est zéro, il prend la valeur false , sinon il prend la valeur true . Dans les deux cas, il continue d'évaluer l'expression.
& et && :
& fonctionne bit par bit en && ne tient compte que zéro et non zéro et renvoie toujours 0 ou 1. Ainsi 5 & 6 < / code> (binaire 101 & 110 ) donne 4 (binaire 100 ), tandis que 5 && 6 donne 1 ( true ).
&& "circuits courts". Si la première valeur est égale à zéro, il n'évalue pas la deuxième valeur. & n'a pas cette règle. Ceci est important de plusieurs façons:
& ces effets secondaires arrivent toujours, alors qu'avec && ils ne le font pas. Donc, x et (y ++) toujours incrément y , tandis que x && (y ++) ne incrément y si x est non nul. Cela devient plus important, et peut-être plus subtile, si le second opérande est un appel de fonction.
x! = NULL && X-> foo == 3 . Avec & , lorsque x est null , qui pourrait bombarder avec des défauts de segment ou l'équivalent.
x! = 'A' && readTonsOfStuffFromDatabaseAndCalculateTotal (x) . Avec & , la lecture se serait produit, et peut-être une perte de temps.
&& pour des choses qui sont vraiment des opérations logiques, et de limiter l'utilisation de & quand nous voulons vraiment une opération sage peu. Mais il y a des moments où vous ne voulez pas le court-circuit se produise, et dans ce cas, & peut être un bon choix. Mais si vous l'utilisez pour « logiquement », être très prudent avec des opérandes qui peuvent avoir des valeurs autres que 0 ou 1. 1 && 2 est true , mais 1 & 2 est false .
Merci pour en fait l'expliquant
Notez que dans C #, l'opérateur && BOOL , alors demandez si le premier opérande est zéro n'a aucun sens (en C # A BOOL < / code> ne peut être que faux ou true , jamais un numéro), et en particulier 5 && 6 n'est pas autorisé. Mais la description est pertinente pour d'autres langues.
Oups, je suis dérivé de C # à C / C ++.
Si vous pensez à cette déclaration ... c'est inefficace.
Je l'ai eu de cette question