web-dev-qa-db-fra.com

Meilleure façon 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;
}
c++cbooleanboolean-logic
108
John T

Vous pouvez retourner une valeur comme ceci:

myVal = !myVal;

afin que votre code se raccourcisse à:

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

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}
316
John T

Clairement, vous avez 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>
74
Drew

Si vous connaissez les valeurs 0 ou 1, vous pouvez faire flipval ^= 1.

33
Mike Dunlavey

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

x ^= true;
26
xamid

Juste pour information - si au lieu d'un entier votre champ requis est un bit dans un type plus grand, utilisez l'opérateur 'xor' à la place:

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;
10
Alnitak

Cela semble être un gratuit pour tous ... Heh. Voici une autre variante, 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 laconique
  • Ne nécessite pas de branchement

Et un inconvénient tout aussi évident est

  • Très laconique

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

9
unwind

Tout simplement parce que mon moyen de balle favori préféré pour basculer un booléen n'est pas répertorié ...

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

fonctionne aussi. :)

(Oui le x = !x; est plus clair et plus facile à lire)

8
Rozwel

La solution de codegolf'ish serait plus comme:

flipVal = (wParam == VK_F11) ? !flipVal : flipVal;
otherVal = (wParam == VK_F12) ? !otherVal : otherVal;
6
korona
flipVal ^= 1;

de même pour

otherVal
2
evandrix

Je préfère la solution de John T., mais si vous voulez tout faire, 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;
2
JosephStyons

Il est clair que vous avez besoin d’une solution flexible pouvant prendre en charge les types se faisant passer pour des valeurs booléennes. Ce qui suit permet pour cela:

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

Vous pouvez ensuite vous spécialiser pour différents types pouvant 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.

0
dma