बूलियन मूल्य फ्लिप करने के लिए सबसे आसान तरीका?

Question

मैं बस एक बूलियन को फ्लिप करना चाहता हूं जो पहले से ही है। अगर यह सच है - इसे गलत बनाओ। यदि यह गलत है - इसे सच करें।

यहाँ मेरा कोड अंश है:

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

Answer 1

आप एक मूल्य को इस तरह फ्लिप कर सकते हैं:

myVal = !myVal;

तो आपका कोड निम्न हो जाएगा:

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

    case VK_F12:
    otherVal = !otherVal;
    break;

    default:
    break;
}

Comments

यह न केवल सबसे आसान है, बल्कि सबसे साफ तरीका भी है।

— शार्प्यूट

दो मामलों का विलय किया जा सकता है क्योंकि वे एक ही काम करते हैं।

— डेविड एलन फ़ंच

डिफ़ॉल्ट है: ब्रेक; वास्तव में आवश्यक है? क्या इसके बिना स्विच का अंत नहीं होगा?

— क्रिस लुत्ज

डिफ़ॉल्ट: ब्रेक; अनावश्यक है।

— रॉब के

यदि आप ऑब्जेक्ट1-> system1.system2.system3.parameter1 की तरह लंबे समय से प्रसारित कर रहे हैं तो यह TOGGLE (a) मैक्रो के लिए सहायक हो सकता है। यह कुछ गलतियों को रोकता है और संकीर्ण स्क्रीन पर इसे और अधिक पठनीय बनाता है।

— OJW

Answer 2

स्पष्ट रूप से आपको फैक्टरी पैटर्न की आवश्यकता है!

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>

Comments

हम शायद कारखाने के लिए सिंगलटन पैटर्न में भी जोड़ सकते हैं।

— आकर्षित किया

कारण @Orm आप एक कर रहे हैं ORM ? :)

— mlvljr

जावा पर स्विच करने के लिए सूक्ष्म अनुशंसा पर ध्यान दें!

— मैकेनिकल घोंघा

खैर ... मुझे लगता है कि हमें इस के लिए C ++ की एक और बड़ी रिलीज की जरूरत है, C ++ / 51 हो सकता है

— 0x6900

हे लोगों! मुझे लगता है कि आपका दृष्टिकोण रीटेंटेंट नहीं है। आपको कम से कम, बेहतर म्यूटेक्स या एक इवेंट कतार में atomic_bool की आवश्यकता है। इसके अलावा, हमें घाटी की स्थिति की निगरानी के लिए एक पर्यवेक्षक-पैटर्न की आवश्यकता है।

— मार्को फ्रायडेनबर्गर

Answer 3

यदि आप जानते हैं कि मान 0 या 1 हैं, तो आप कर सकते हैं flipval ^= 1।

Comments

एक तार्किक ऑपरेशन के लिए एक बिटवाइज़ ऑपरेटर का उपयोग क्यों करें? मेरे लिए बेवजह की गंध आती है।

— मार्क पेम

@ मर्क: क्षमा करें। लगता है कि मैं पुराने जमाने का हूं। लेकिन यह मदद करता है अगर आपका एल-मूल्य अभिव्यक्ति वास्तव में लंबा है, तो आपको इसे दोहराना नहीं है। इसके अलावा, आप फ्लिपकार्ट ^ = TRUE कह सकते हैं। क्या वो बेहतर है?

— माइक डनलवेई

@Alnitak: आप कुछ परिस्थितियों में सही हैं। मैंने कुछ लोगों को "स्पेस बचाने" के लिए बिट्स को एक साथ पैक करते हुए देखा है और एक्ट करता है जैसे कि उन्हें एक्सेस करने के निर्देश ने कोई स्पेस नहीं लिया।

— माइक डनलैवी

@Albert: ^है अनन्य या ऑपरेटर। 0^1है 1, और 1^1है 0। यदि आप कैरी बिट को अनदेखा करते हैं तो यह जोड़ने के समान है। या आप इसके बारे में सोच सकते हैं - यदि या तो बिट 1 है, तो परिणाम दूसरे बिट का व्युत्क्रम है। या आप सवाल पूछने के बारे में सोच सकते हैं: क्या ये दोनों बिट्स अलग हैं?

— माइक डनलैवी

@MikeDunlavey अगर आप कोड स्पेस के लिए 4M फ्लैश के साथ एक डिवाइस पर हैं, और डेटा स्पेस के लिए SRK का 3K है तो यह अभिनय का एक न्यायसंगत तरीका है!

— MM

Answer 4

सबसे आसान समाधान जो मुझे मिला:

x ^= true;

Comments

x = !x;न केवल कम है, बल्कि अधिक सुपाठ्य है।

— रॉड्रिगो

ध्यान दें कि उदा longVariableName ^= true;स्पष्ट रूप से कम है longVariableName = !longVariableName;और प्रत्येक प्रोग्रामर को XOR पता होना चाहिए।

— ६:१५ पर xamid

a ^= bसाधन a = a ^ b, जहां ^XOR का मतलब है। अंकन a °= bके लिए a = a ° bकिसी भी ऑपरेटर के लिए °C / C ++ / सी # वाक्य रचना के बीच बहुत आम है।

— xamid

किस्सा, लेकिन मैं हाल ही में लाइन के पार आया था gRackWidget->modules->first().lights[PATTERN1_LIGHT + i].value = !gRackWidget->modules->first().lights[PATTERN1_LIGHT + i].value;, सबसे साफ बात यह है कि इसे कई लाइनों में विस्तारित करना है और वस्तुओं को संग्रहीत करने के लिए अस्थायी चर का उपयोग करना है, लेकिन gRackWidget->modules->first().lights[PATTERN1_LIGHT + i].value ^= 1मूल कोड की तुलना में बहुत अधिक पठनीय, कम त्रुटि प्रवण और कम वर्ण हैं। ।

— वोर्टिको

इसके अतिरिक्त, कम दोहराव का अर्थ है तेजी से विकास परिवर्तन / कोडिंग के लंबे दिनों / रातों के दौरान समीकरण के दोनों पक्षों को अपडेट करने के लिए भूलने की कम संभावना।

— 1

Answer 5

बस जानकारी के लिए - यदि किसी पूर्णांक के बजाय आपका आवश्यक फ़ील्ड एक बड़े प्रकार के भीतर एक सा है, तो इसके बजाय '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;

Answer 6

यह एक मुक्त सभी के लिए लगता है ... हेह। यहाँ एक और संस्करण है, जो मुझे लगता है कि "चतुर" श्रेणी में अधिक है, जो कुछ मैं उत्पादन कोड के लिए सुझाऊंगा:

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

मुझे लगता है कि यह फायदे हैं:

• बहुत ही तंदुरुस्त
• ब्रांचिंग की आवश्यकता नहीं है

और बस के रूप में स्पष्ट नुकसान है

• बहुत ही तंदुरुस्त

यह @ कोरोना समाधान का उपयोग कर के करीब है ?: लेकिन एक (छोटा) कदम आगे बढ़ाया।

Comments

संचालन के आदेश से, मुझे लगता है कि आप कोष्ठक को और भी अधिक छंद के लिए छोड़ सकते हैं। : ओ

— आकर्षित

Answer 7

सिर्फ इसलिए कि मेरे मनपसंद अजीब बॉल टॉगल करने का तरीका सूचीबद्ध नहीं है ...

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

काम भी करता है। :)

(हां x = !x;स्पष्ट और पढ़ने में आसान है)

Answer 8

Codegolf'ish समाधान अधिक पसंद किया जाएगा:

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

Answer 9

मैं जॉन टी के समाधान को पसंद करता हूं, लेकिन यदि आप सभी कोड-गोल्फ जाना चाहते हैं, तो आपका बयान तार्किक रूप से इसे कम कर देता है:

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

Comments

क्या आपको VK_F11 और VK_F12 के खिलाफ wParam की जांच नहीं करनी है?

— drby

Answer 10

flipVal ^= 1;

वही जाता है

otherVal

Answer 11

स्पष्ट रूप से आपको एक लचीले समाधान की आवश्यकता होती है जो बूलियन के रूप में प्रकार के आवरण का समर्थन कर सकता है। निम्नलिखित उस के लिए अनुमति देता है:

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

नहीं, मैं गंभीर नहीं हूं।

Answer 12

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

Answer 13

सिर्फ इसलिए कि मुझे प्रश्न कोड पसंद है। मेरा प्रस्ताव है कि आप इस तरह से कुछ करके टर्नरी का उपयोग कर सकते हैं:

उदाहरण:

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