Der einfachste Weg, einen Booleschen Wert zu kippen?

Question

Ich möchte nur ein boolean Flip auf, was es ohnehin schon ist. Wenn es wahr ist - es falsch machen. Wenn es falsch ist -. Macht 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;
}

Answer 1

Sie können einen Wert Flip etwa so:

myVal = !myVal;

, damit Ihr Code würde verkürzen bis auf:

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

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}

Answer 2

Selbstverständlich müssen Sie eine Fabrik Muster!

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>

Answer 3

Wenn Sie die Werte 0 oder 1 wissen, könnten Sie flipval ^= 1 tun.

Answer 4

Die einfachste Lösung, die ich gefunden:

x ^= true;

Answer 5

Nur zur Information - wenn statt einer ganzen Zahl Ihr erforderliches Feld ein einzelnes Bit in einem größeren Typ ist, verwenden Sie den ‚xor‘ Operator statt:

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;

Answer 6

Dies scheint ein free-for-all ... Heh zu sein. Hier ist ein weiterer varation, die ich schätze, ist in der Kategorie „clever“ als etwas, das ich für die Produktion Code empfehlen würde:

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

Ich denke, es ist Vorteile sind:

• Sehr kurz und bündig
• Ist Verzweigung nicht erforderlich

Und ein ebenso offensichtlicher Nachteil ist

• Sehr kurz und bündig

Dies ist in der Nähe @ korona-Lösung mit:. Aber einen (kleiner) Schritt weiter

Answer 7

Nur weil mein Liebling ungeradeer Ball Art und Weise einen Bool zu wechseln ist nicht aufgelistet ...

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

funktioniert auch. :)

(ja die x = !x; ist klarer und leichter zu lesen)

Answer 8

Die codegolf'ish Lösung wäre wie:

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

Answer 9

ich lieber John T-Lösung, aber wenn Sie den gesamten Code-Golfy gehen wollen, Ihre Aussage reduziert logisch folgt aus:

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

Answer 10

flipVal ^= 1;

Dies gilt auch für

otherVal

Answer 11

Selbstverständlich benötigen Sie eine flexible Lösung, die Typen getarnt als boolean unterstützen kann. Im Folgenden ermöglicht, dass:

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

Sie können dann diese spezialisiert für verschiedene Typen, die boolean sein könnte vorgeben. Zum Beispiel:

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 bin nicht ernst.