วิธีที่ง่ายที่สุดในการพลิกค่าบูลีน

ฉันแค่ต้องการพลิกบูลีนตามสิ่งที่มีอยู่แล้ว ถ้าเป็นจริง - ทำให้เป็นเท็จ หากเป็นเท็จ - ทำให้เป็นจริง

นี่คือรหัสที่ตัดตอนมาของฉัน:

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

: D

</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);

MWE ใน 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;
}

เพียงเพราะฉันชอบถามรหัส ฉันขอเสนอว่าคุณสามารถใช้ประโยชน์จาก ternary ได้โดยทำสิ่งนี้:

ตัวอย่าง:

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