Najprostszy sposób na odwrócenie wartości logicznej?

Najwyraźniej potrzebujesz fabrycznego wzoru!

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>

Jeśli wiesz, że wartości są 0 LUB 1, możesz zrobić flipval ^= 1.

Najprostsze rozwiązanie jakie znalazłem:

x ^= true;

Tylko dla informacji-jeśli zamiast liczby całkowitej Wymagane pole jest pojedynczym bitem w większym typie, użyj operatora '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;

To wydaje się być free-for-all ... Heh. Oto kolejna odmiana, która chyba jest bardziej w kategorii "sprytna" niż coś, co polecam do kodu produkcji:

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

Myślę, że jego zalety to:

• bardzo zwięzłe
• nie wymaga rozgałęziania

I równie oczywistą wadą jest

• bardzo zwięzłe

To jest zbliżone do rozwiązania @ korona za pomocą ?: ale zrobił jeden (mały) krok dalej.

Tylko dlatego, że mój ulubiony dziwny sposób na przełączenie boola nie jest wymieniony...

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

Też działa. :)

(Tak x = !x; jest jaśniejszy i łatwiejszy do odczytania)

Rozwiązanie codegolf ' ish byłoby bardziej jak:

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

Preferuję rozwiązanie Johna T, ale jeśli chcesz iść na całego code-golfy, twoja wypowiedź logicznie redukuje się do tego:

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

To samo dotyczy

otherVal

Oczywiście potrzebujesz elastycznego rozwiązania, które może obsługiwać typy maskujące się jako logiczne. Pozwala na to:

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

Możesz następnie specjalizować to dla różnych typów, które mogą udawać, że są logiczne. Na przykład:

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

Przykład użycia tej konstrukcji:

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