翻转布尔值最简单的方法是什么？

我只是想根据布尔值已经是什么来反转一个布尔值。如果是真的，就让它变成假的。如果是假的，就让它成真。

以下是我的代码摘录:

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;
}
275703 次浏览
小开
最佳答案

你可以像这样翻转一个值:

myVal = !myVal;

所以你的代码会缩短到:

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


case VK_F12:
otherVal = !otherVal;
break;


default:
break;
}
小开

我比较喜欢 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;
小开

代码高尔夫的解决方案更像是:

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

如果知道值是0或1，就可以执行 flipval ^= 1。

小开

显然，您需要一个工厂模式！

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>
小开

仅供参考——如果你所需要的字段是一个较大类型中的一个位，而不是一个整数，那么使用“ 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;
小开

显然，您需要一个灵活的解决方案来支持伪装成布尔型的类型:

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

不，我不是认真的。

小开

这看起来像是一场混战。下面是另外一个变体，我猜它更像是“聪明”这一类，而不是我推荐给产品代码的那种:

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

我想它的优势是:

  • 非常简洁
  • 不需要分支

同样明显的劣势是

  • 非常简洁

这与使用? : 的@korona 解决方案非常接近，但是又向前迈进了一小步。

小开

只是因为我最喜欢的切换球的奇怪方式没有被列出来。

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

:)

(是的，x = !x;更清晰，更容易阅读)

小开 
flipVal ^= 1;

我也一样

otherVal
小开

我找到的最简单的解决办法:

x ^= true;
小开

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

value = abs(value - 1);

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

就因为我喜欢质疑代码。我建议您也可以通过执行以下操作来利用三元结构:

例如:

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

提交答案