Cách dễ nhất để lật một giá trị boolean?

Tôi chỉ muốn lật một boolean dựa trên những gì nó đã có. Nếu nó đúng - làm cho nó sai. Nếu nó sai - làm cho nó đúng.

Đây là đoạn trích mã của tôi:

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

Bạn có thể lật một giá trị như vậy:

myVal = !myVal;

vì vậy mã của bạn sẽ rút ngắn xuống:

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

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}

Rõ ràng bạn cần một mô hình nhà máy!

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>

Nếu bạn biết các giá trị là 0 hoặc 1, bạn có thể làm flipval ^= 1.

Giải pháp dễ nhất mà tôi tìm thấy:

x ^= true;

Chỉ để biết thông tin - nếu thay vì số nguyên, trường bắt buộc của bạn là một bit trong loại lớn hơn, hãy sử dụng toán tử 'xor' thay thế:

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;

Đây dường như là một thứ miễn phí cho tất cả ... Heh. Đây là một biến thể khác, mà tôi đoán là trong danh mục "thông minh" hơn là thứ tôi khuyên dùng cho mã sản xuất:

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

Tôi đoán đó là ưu điểm của nó là:

• Rất ngắn gọn
• Không yêu cầu phân nhánh

Và một nhược điểm rõ ràng là

• Rất ngắn gọn

Điều này gần với giải pháp của @ korona bằng cách sử dụng ?: Nhưng đã tiến thêm một bước (nhỏ).

Chỉ vì cách bóng kỳ lạ yêu thích của tôi để chuyển đổi một bool không được liệt kê ...

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

làm việc quá :)

(vâng, x = !x;rõ ràng và dễ đọc hơn)

Giải pháp codegolf'ish sẽ giống như:

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

Tôi thích giải pháp của John T, nhưng nếu bạn muốn chơi tất cả các môn đánh gôn, tuyên bố của bạn sẽ giảm một cách hợp lý điều này:

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

cũng vậy

otherVal

Rõ ràng bạn cần một giải pháp linh hoạt có thể hỗ trợ các kiểu giả mạo như boolean. Sau đây cho phép:

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

Sau đó, bạn có thể chuyên môn hóa này cho các loại khác nhau có thể giả vờ là boolean. Ví dụ:

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

Một ví dụ về việc sử dụng cấu trúc này:

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

Không, tôi không nghiêm túc.

Đối với các số nguyên có giá trị 0 và 1, bạn có thể thử:

value = abs(value - 1);

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

Chỉ vì tôi thích đặt câu hỏi về mã. Tôi đề nghị rằng bạn cũng có thể sử dụng chim nhạn bằng cách làm một cái gì đó như thế này:

Thí dụ:

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