c++ - usar - que es booleano en programacion

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

Question

Solo quiero darle la vuelta a un booleano basado en lo que ya es. Si es verdad, hazlo falso. Si es falso, hazlo cierto.

Aquí está mi extracto del 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

¡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>

Answer 2

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

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

A continuación, 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 usar 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 lo digo en serio.

Answer 3

Esto parece ser una liberación para todos ... Heh. Aquí hay otra variación, que creo 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);

Creo que sus ventajas son:

• Muy escueto
• No requiere ramificación

Y una desventaja tan obvia es

• Muy escueto

Esto está cerca de la solución de @korona usando?: Pero dio un paso más.

Answer 4

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

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

Answer 5

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

x ^= true;

Answer 6

Puedes voltear un valor como ese:

myVal = !myVal;

para que tu código se reduzca a:

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

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}

Answer 7

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

Answer 8

Solo para obtener información: si en vez de un número entero, su campo obligatorio es un único 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 & flab_b) != 0;

Answer 9

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

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

funciona también :)

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

Answer 10

Yo prefiero la solución de John T, pero si quieres usar code-golfy, tu afirmación lógicamente se reduce 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 11

flipVal ^= 1;

lo mismo vale para

otherVal