부울 값을 가장 쉽게 플립할 수 있는 방법?

부울 값을 가장 쉽게 플립할 수 있는 방법?

나는 단지 부울이 이미 무엇인지에 근거하여 뒤집기를 원한다.그것이 사실이라면 - 거짓으로 만드세요.만약 그것이 거짓이라면 - 그것을 진실되게 만드세요.

여기 내 코드 발췌문이 있다.

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

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

x ^= true;

공장 패턴이 필요하겠군!

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>

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

참고로 필요한 필드가 정수 대신 큰 유형 내의 단일 비트인 경우 '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;

내가 가장 좋아하는 이상한 볼 토글 방법이 목록에 없다고 해서...

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

역시 효과가 있다.:)

(그렇다)x = !x;더 명확하고 읽기 쉽다)

코드골프의 해결책은 다음과 같다.

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

flipVal ^= 1;

에 대해서도 마찬가지다.

otherVal

이것은 누구나 다 할 수 있는 일인 것 같다.허허. 여기 또 다른 변형이 있는데, 내가 생산 코드에 추천하고 싶은 것 보다 "깨끗한" 범주에 더 들어 있는 것 같다.

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

장점은 다음과 같다.

• 매우 간결하다
• 분기할 필요 없음

그리고 분명한 단점은

• 매우 간결하다

이것은 ?:를 사용한 @korona의 용액에 가깝지만 한 걸음 더 나아갔다.

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

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

아니, 난 진지하지 않아.

단지 내가 코드에 의문을 제기하는 것을 좋아하기 때문에.나는 다음과 같은 일을 함으로써 3차원의 활용도 제안한다.

예:

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

값이 0과 1인 정수의 경우 다음을 시도해 보십시오.

value = abs(value - 1);

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

나는 존 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;

참조URL: https://stackoverflow.com/questions/610916/easiest-way-to-flip-a-boolean-value