Le moyen le plus simple de retourner une valeur booléenne?

Je veux juste retourner un booléen basé sur ce qu'il est déjà. Si c'est vrai, faites-le faux. Si c'est faux, rendez-le vrai.

Voici mon extrait de code:

switch(wParam) {

case VK_F11:
  if (flipVal == true) {
     flipVal = false;
  } else {
    flipVal = true;
  }
break;

case VK_F12:
  if (otherVal == true) {
     otherValVal = false;
  } else {
    otherVal = true;
  }
break;

default:
break;
}

Vous pouvez inverser une valeur comme ceci:

myVal = !myVal;

donc votre code se réduirait à:

switch(wParam) {
    case VK_F11:
    flipVal = !flipVal;
    break;

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}

Vous avez clairement besoin d'un modèle d'usine!

KeyFactory keyFactory = new KeyFactory();
KeyObj keyObj = keyFactory.getKeyObj(wParam);
keyObj.doStuff();


class VK_F11 extends KeyObj {
   boolean val;
   public void doStuff() {
      val = !val;
   }
}

class VK_F12 extends KeyObj {
   boolean val;
   public void doStuff() {
      val = !val;
   }
}

class KeyFactory {
   public KeyObj getKeyObj(int param) {
      switch(param) {
         case VK_F11:
            return new VK_F11();
         case VK_F12:
            return new VK_F12();
      }
      throw new KeyNotFoundException("Key " + param + " was not found!");
   }
}

:RÉ

</sarcasm>

Si vous savez que les valeurs sont 0 ou 1, vous pouvez le faire flipval ^= 1.

La solution la plus simple que j'ai trouvée:

x ^= true;

Juste pour information - si au lieu d'un entier, votre champ obligatoire est un seul bit dans un type plus grand, utilisez plutôt l'opérateur 'xor':

int flags;

int flag_a = 0x01;
int flag_b = 0x02;
int flag_c = 0x04;

/* I want to flip 'flag_b' without touching 'flag_a' or 'flag_c' */
flags ^= flag_b;

/* I want to set 'flag_b' */
flags |= flag_b;

/* I want to clear (or 'reset') 'flag_b' */
flags &= ~flag_b;

/* I want to test 'flag_b' */
bool b_is_set = (flags & flag_b) != 0;

Cela semble être un free-for-all ... Heh. Voici une autre variation, qui, je suppose, est plus dans la catégorie «intelligente» que quelque chose que je recommanderais pour le code de production:

flipVal ^= (wParam == VK_F11);
otherVal ^= (wParam == VK_F12);

Je suppose que ses avantages sont:

• Très concis
• Ne nécessite pas de branchement

Et un inconvénient tout aussi évident est

• Très concis

Ceci est proche de la solution de @ korona utilisant?: Mais fait un (petit) pas plus loin.

Juste parce que ma manière préférée de faire basculer un booléen n'est pas répertoriée ...

bool x = true;
x = x == false;

fonctionne aussi. :)

(oui x = !x;c'est plus clair et plus facile à lire)

La solution codegolf'ish serait plus comme:

flipVal = (wParam == VK_F11) ? !flipVal : flipVal;
otherVal = (wParam == VK_F12) ? !otherVal : otherVal;

Je préfère la solution de John T, mais si vous voulez passer au code-golfy, votre déclaration se réduit logiquement à ceci:

//if key is down, toggle the boolean, else leave it alone.
flipVal = ((wParam==VK_F11) && !flipVal) || (!(wParam==VK_F11) && flipVal);
if(wParam==VK_F11) Break;

//if key is down, toggle the boolean, else leave it alone.
otherVal = ((wParam==VK_F12) && !otherVal) || (!(wParam==VK_F12) && otherVal);
if(wParam==VK_F12) Break;

flipVal ^= 1;

de même pour

otherVal

Il est clair que vous avez besoin d'une solution flexible capable de prendre en charge les types se faisant passer pour des booléens. Ce qui suit permet cela:

template<typename T>    bool Flip(const T& t);

Vous pouvez ensuite le spécialiser pour différents types qui pourraient prétendre être booléens. Par exemple:

template<>  bool Flip<bool>(const bool& b)  { return !b; }
template<>  bool Flip<int>(const int& i)    { return !(i == 0); }

Un exemple d'utilisation de cette construction:

if(Flip(false))  { printf("flipped false\n"); }
if(!Flip(true))  { printf("flipped true\n"); }

if(Flip(0))  { printf("flipped 0\n"); }
if(!Flip(1)) { printf("flipped 1\n"); }

Non, je ne suis pas sérieux.

Pour les entiers avec des valeurs de 0 et 1, vous pouvez essayer:

value = abs(value - 1);

MWE en C:

#include <stdio.h>
#include <stdlib.h>
int main()
{
        printf("Hello, World!\n");
        int value = 0;
        int i;
        for (i=0; i<10; i++)
        {
                value = abs(value -1);
                printf("%d\n", value);
        }
        return 0;
}

Juste parce que j'aime remettre en question le code. Je propose que vous puissiez également utiliser le ternaire en faisant quelque chose comme ceci:

Exemple:

bool flipValue = false;
bool bShouldFlip = true;
flipValue = bShouldFlip ? !flipValue : flipValue;