부울 값을 뒤집는 가장 쉬운 방법은 무엇입니까?

이미 무엇인지에 따라 부울을 뒤집고 싶습니다. 그것이 사실이라면-거짓으로 만드십시오. 거짓이라면-사실로 만드십시오.

다음은 내 코드 발췌입니다.

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

다음과 같이 값을 뒤집을 수 있습니다.

myVal = !myVal;

따라서 코드는 다음과 같이 단축됩니다.

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

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}

분명히 공장 패턴이 필요합니다!

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

:디

</sarcasm>

값이 0 또는 1 인 것을 알고 있다면 flipval ^= 1.

내가 찾은 가장 쉬운 솔루션 :

x ^= true;

정보를 위해-정수 대신 필수 필드가 더 큰 유형 내에서 단일 비트 인 경우 대신 '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;

이것은 모두를위한 자유인 것 같습니다. 다음은 프로덕션 코드에 권장하는 것보다 "영리한"범주에 더 많은 다른 변형이 있다고 생각합니다.

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

장점은 다음과 같습니다.

• 매우 간결
• 분기가 필요하지 않습니다.

그리고 명백한 단점은

• 매우 간결

이것은? :를 사용하는 @korona의 솔루션에 가깝지만 한 단계 더 나아갔습니다.

부울을 토글하는 내가 가장 좋아하는 이상한 공 방법이 나열되지 않기 때문에 ...

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

너무 작동합니다. :)

(예, x = !x;더 명확하고 읽기 쉽습니다)

codegolf'ish 솔루션은 다음과 같습니다.

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

나는 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 ^= 1;

똑같다

otherVal

분명히 부울로 가장하는 유형을 지원할 수있는 유연한 솔루션이 필요합니다. 다음은이를 허용합니다.

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

아니, 진지하지 않아.

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

나는 질문 코드를 좋아하기 때문에. 다음과 같이하여 삼항을 사용할 수도 있습니다.

예:

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