Der einfachste Weg, einen Booleschen Wert umzudrehen?

Ich möchte nur einen Booleschen Wert umdrehen, basierend auf dem, 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;
}

Sie können einen Wert wie folgt umdrehen:

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

Natürlich brauchen Sie 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>

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

Die einfachste Lösung, die ich gefunden habe:

x ^= true;

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;

Dies scheint ein Alleskönner zu sein ... Heh. Hier ist eine weitere Variante, die meiner Meinung nach eher in der Kategorie "clever" liegt 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 Lösung von @ korona mit ?: Nahe, geht aber noch einen (kleinen) Schritt weiter.

Nur weil meine Lieblingsmethode 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)

Die Codegolf-Lösung wäre eher wie folgt:

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

Ich bevorzuge die Lösung von John T, aber wenn Sie nur Code-Golf spielen möchten, 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;

flipVal ^= 1;

Gleiches gilt für

otherVal

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

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

Sie können dies dann auf verschiedene Typen spezialisieren, die sich als boolesch ausgeben. 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, ich meine es nicht ernst.

Für ganze Zahlen mit den Werten 0 und 1 können Sie Folgendes versuchen:

value = abs(value - 1);

MWE in 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;
}

Nur weil ich gerne Code frage. Ich schlage vor, dass Sie das Ternäre auch nutzen können, indem Sie so etwas tun:

Beispiel:

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