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

Question

Solo quiero cambiar 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;
}

Answer 1

Puedes cambiar un valor así:

myVal = !myVal;

para que su código se acorte a:

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

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}

Answer 2

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

: D

</sarcasm>

Answer 3

Si sabe que los valores son 0 o 1, puede hacer flipval ^ = 1 .

Answer 4

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

x ^= true;

Answer 5

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;

Answer 6

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á.

Answer 7

Solo porque mi forma de bola extraña favorita para cambiar un bool no está en la lista ...

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

también funciona. :)

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

Answer 8

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

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

Answer 9

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;

Answer 10

flipVal ^= 1;

lo mismo vale para

otherVal

Answer 11

Es evidente que necesita una solución flexible que pueda admitir tipos disfrazados de booleanos. Lo siguiente lo permite:

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

Luego, puede especializar esto para diferentes tipos que puedan 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.