Comment basculer un int / _Bool en C

Supposons que nous avons un int et souhaitez basculer entre 0 et 1 dans un booléen de la mode. J'ai pensé aux possibilités suivantes:

int value = 0; //May as well be 1

value = value == 0 ? 1 : 0;
value = (value + 1) % 2;
value = !value; //I was curious if that would do...
  1. Le troisième semble fonctionner. Pourquoi? Qui décide que !0 est 1?
  2. Est quelque chose de mal avec l'un de ces?
  3. Existe-il d'autres possibilités? par exemple, les opérateurs sur les bits?
  4. Qui offre les meilleures performances?
  5. Seraient tous être identiques avec _Bool (ou bool de stdbool.h)? Si non, quelles sont les différences?

EDIT: Beaucoup de grandes réponses avec beaucoup d'informations précieuses, merci! Malheureusement, je ne peux accepter.

source d'informationauteur riha

  1. 23

    value = !value; exprime ce que vous voulez faire directement, et c'est exactement ce que vous voulez faire, par définition.

    Utiliser cette expression.

    De C99 6.5.3.3/5 "opérateurs arithmétiques Unaires":

    Le résultat de la négation logique de l'opérateur ! est 0 si la valeur de ses
    opérande compare inégale à 0, 1 si la valeur de son opérande compare
    égal à 0. Le résultat est de type int. L'expression !E est équivalent
    (0==E).

  2. 10

    Le troisième semble fonctionner. Pourquoi? Qui en décide !0 est 1?

    C Standard garantit que !0 est 1.

    Existe-il d'autres possibilités? par exemple, les opérateurs sur les bits?

    Oui, vous pouvez utiliser le OU exclusif de l'opérateur:

    value ^= 1;

    Par la façon dont je préfère cela à value = !value; relationnelles et des opérateurs d'égalité peut entraîner de branchement et les opérateurs au niveau du bit généralement pas.

  3. 3

    value = !value semble la plus raisonnable, mais vous pouvez également utiliser value = 1 - value ou value ^= 1. Mais les deux derniers permettrait à la fois de se briser si value n'est pas 0 ou 1. Le premier fonctionne encore.

  4. 3

    Il peut être perceptible problèmes de performances avec les solutions de rechange en fonction de l'architecture:

    • !un besoin dans certaines architectures de comparaison et de ramification, qui peut être coûteux en fonction du modèle de 'a'
      • sur certaines architectures, il est conditionnelle déplacer (ce qui est dépourvu de branches), mais

        ce qui peut nécessiter encore 3 instructions pour terminer (avec dépendances)
    • 1-a probablement besoin de deux instructions dans de nombreuses architectures
      • contre-exemple: le BRAS inverse soustraction RSB %r0, %r0, #1
    • 1^un peut être mis en œuvre dans de nombreux architecture en une seule instruction
    • un=(un+1) % 2 sera probablement optimisé pour un=(un+1)&1, qui exige 2 instructions

    Mais de toute façon la première règle de l'optimisation est qui n'optimisent pas non code du travail.
    Pour le remplacer !un avec a^1, on doit être à 100% certain qu'il produit toujours de la valeur attendue.

  5. 3
    1. le langage a été conçu de cette façon.
    2. Utiliser la 3ème, les autres sont justes mais unnecessarly compliqué et il faut donc se cacher à l'intention.
    3. value = (value ^ 1) & 1;
    4. Ils sont tout de même après optimisation.
    5. _Bool aurait les mêmes résultats. La seule chose de différent avec _Bool, c'est que les valeurs sont contraints à être 1 ou 0. Ce qui signifie que bool x = 55; aura la valeur x == 1

    EDIT: correction de la formule en 3 à cause de mon brainfart. Je laisse les commentaires, afin que les gens puissent voir mon erreur.

  6. 1

    Votre expression value = value == 0 ? 1 : 0; fonctionnera exactement comme value = !value;. Vous pouvez utiliser l'un des deux.

    !0 est toujours 1 et aussi !(any non zero value) est 0

  7. 0

    En C#, vous pouvez utiliser Math.Abs(value -1) pour basculer entre zéro et un, comme des entiers.

  8. 0
    value = 1 - value; //toggle from 0 to 1 ... or 1 to 0
                   //when you know initial value is either 0 or 1