it-swarm.com.de

Der einfachste Weg, einen Booleschen Wert umzukehren?

Ich möchte nur einen Booleschen Wert umdrehen, der auf dem basiert, was er bereits ist. Wenn es wahr ist - mach es falsch. Wenn es falsch ist - mach es wahr.

Hier ist mein Code-Auszug:

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;
}
108
John T

Sie können einen Wert wie folgt spiegeln:

myVal = !myVal;

ihr Code würde sich also verkürzen auf:

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

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}
316
John T

Klar, Sie brauchen ein Fabrikmuster!

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!");
   }
}

: D

</sarcasm>
74
Drew

Wenn Sie wissen, dass die Werte 0 oder 1 sind, können Sie flipval ^= 1.

33
Mike Dunlavey

Die einfachste Lösung, die ich gefunden habe:

x ^= true;
26
xamid

Nur zur Information: Wenn Ihr erforderliches Feld anstelle einer Ganzzahl ein einzelnes Bit innerhalb eines größeren Typs ist, verwenden Sie stattdessen den Operator '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;
10
Alnitak

Dies scheint ein Alleskönner zu sein ... Heh. Hier ist eine weitere Variante, die meiner Meinung nach eher zur Kategorie "clever" gehört als etwas, das ich für den Produktionscode empfehlen würde:

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

Ich denke, die Vorteile sind:

  • Sehr knapp
  • Benötigt keine Verzweigung

Und ein ebenso offensichtlicher Nachteil ist

  • Sehr knapp

Dies kommt der @ korona-Lösung nahe, die?: Verwendet, ist aber noch einen (kleinen) Schritt weiter gegangen.

9
unwind

Nur weil meine Lieblings-Methode zum Umschalten eines Bools nicht aufgeführt ist ...

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

funktioniert auch. :)

(Ja das x = !x; ist klarer und leichter zu lesen)

8
Rozwel

Die codegolf'sche Lösung wäre eher wie folgt:

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

gleiches gilt für

otherVal
2
evandrix

Ich bevorzuge die Lösung von John T, aber wenn Sie alles Code-Golfen wollen, reduziert sich Ihre Aussage logischerweise auf Folgendes:

//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

Natürlich benötigen Sie eine flexible Lösung, die Typen unterstützt, die sich als Boolesche Typen tarnen. Folgendes ermöglicht dies:

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

Sie können dies dann auf verschiedene Typen spezialisieren, die vorgeben, Boolesch zu sein. Beispielsweise:

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

Ein Beispiel für die Verwendung dieses Konstrukts:

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"); }

Nein, das meine ich nicht ernst.

0
dma