138

我只想根据它已经是什么来翻转一个布尔值。如果它是真的 - 让它成为假的。如果它是假的 - 让它成为真的。

这是我的代码摘录：

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

13 回答 13

383

您可以像这样翻转一个值：

myVal = !myVal;

因此您的代码将缩短为：

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

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}
于 2009-03-04T14:55:26.467 回答
90

显然你需要一个工厂模式！

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>
于 2009-03-04T16:56:11.667 回答
47

我发现的最简单的解决方案：

x ^= true;
于 2014-03-21T16:46:39.267 回答
43

如果您知道值是 0 或 1，则可以执行flipval ^= 1.

于 2009-03-04T16:55:44.337 回答
15

仅供参考 - 如果您的必填字段不是整数，而是较大类型中的一位，请改用“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;
于 2009-03-04T16:58:35.827 回答
10

这似乎是一个免费的所有人......呵呵。这是另一个变体，我想它比我推荐的生产代码更属于“聪明”类别：

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

我想它的优点是：

  • 非常简洁
  • 不需要分支

一个同样明显的缺点是

  • 非常简洁

这与@korona 使用 ?: 的解决方案很接近，但更进一步。

于 2009-03-05T07:56:17.450 回答
10

只是因为没有列出我最喜欢的切换布尔值的奇数球方式......

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

也可以。:)

（是的x = !x;更清晰，更容易阅读）

于 2012-03-07T20:34:36.893 回答
8

codegolf'ish 解决方案更像是：

flipVal = (wParam == VK_F11) ? !flipVal : flipVal;
otherVal = (wParam == VK_F12) ? !otherVal : otherVal;
于 2009-03-04T16:00:15.903 回答
3 
flipVal ^= 1;

同样适用

otherVal
于 2013-08-31T17:36:05.017 回答
2

我更喜欢 John T 的解决方案，但如果你想全部使用代码，你的陈述在逻辑上会简化为：

//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;
于 2009-03-04T15:25:48.640 回答
1

显然，您需要一个灵活的解决方案来支持伪装成布尔值的类型。以下允许：

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

然后，您可以将其专门用于可能假装为布尔值的不同类型。例如：

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

使用此构造的示例：

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

不，我不是认真的。

于 2009-03-04T17:14:50.437 回答
0

对于值为 0 和 1 的整数，您可以尝试：

value = abs(value - 1);

C中的MWE：

#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;
}
于 2020-01-02T21:10:55.157 回答
0

只是因为我喜欢质疑代码。我建议您也可以通过执行以下操作来使用三元：

例子：

bool flipValue = false;
bool bShouldFlip = true;
flipValue = bShouldFlip ? !flipValue : flipValue;
于 2020-02-23T23:30:30.030 回答