¿La forma más fácil de voltear un valor booleano?

Solo quiero voltear un booleano basado en lo que ya es. Si es verdad, hazlo falso. Si es falso, hazlo verdadero.

Aquí está mi extracto de código:

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

Puede voltear un valor así:

myVal = !myVal;

entonces su código se acortaría a:

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

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}

¡Claramente necesitas un patrón de fábrica!

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

:RE

</sarcasm>

Si sabe que los valores son 0 o 1, podría hacerlo flipval ^= 1.

La solución más fácil que encontré:

x ^= true;

Solo para información: si en lugar de un número entero su campo requerido es un solo bit dentro de un tipo más grande, use el operador 'xor' en su lugar:

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;

Esto parece ser un juego para todos ... Je. Aquí hay otra vacación, que supongo que está más en la categoría "inteligente" que algo que recomendaría para el código de producción:

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

Supongo que sus ventajas son:

• Muy conciso
• No requiere ramificación

Y una desventaja igual de obvia es

• Muy conciso

Esto está cerca de la solución de @ korona usando?: Pero dado un paso (pequeño) más allá.

Solo porque mi forma favorita de alternar una bola no está en la lista ...

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

también funciona :)

(sí, x = !x;es más claro y más fácil de leer)

La solución codegolf'ish sería más como:

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

Prefiero la solución de John T, pero si quieres ir a todo golf, tu declaración se reduce lógicamente a esto:

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

lo mismo va para

otherVal

Claramente, necesita una solución flexible que pueda admitir tipos enmascarados como booleanos. Lo siguiente permite eso:

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

Luego puede especializar esto para diferentes tipos que pueden pretender ser booleanos. Por ejemplo:

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

Un ejemplo de uso de esta construcción:

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

No, no hablo en serio.

Para enteros con valores de 0 y 1 puede intentar:

value = abs(value - 1);

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

Solo porque me gusta cuestionar el código. Propongo que también puede hacer uso del ternario haciendo algo como esto:

Ejemplo:

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