सशर्त XOR?

87

कैसे आए C # में सशर्त XORऑपरेटर नहीं है ?

उदाहरण:

true  xor false = true
true  xor true  = false
false xor false = false

c# operators xor boolean-operations

— गिलाद नमन
स्रोत

15

!=विकल्प के रूप में कैसे काम करता है ?

— पास्कल कूउक

45

सी # करता है एक XOR ऑपरेटर (x ^ y) की है। इसलिए मैं प्रश्न के आधार से इनकार करता हूं। क्या आप बता सकते हैं कि आपने यह क्यों माना कि C # में एक Xor ऑपरेटर नहीं है? मुझे यह जानने में दिलचस्पी है कि लोग C # के बारे में झूठी बातें क्यों मानते हैं।

— एरिक लिपर्ट

3

@ एरिक लिप्टर्ट: मुझे लगता है कि वह तार्किक ऑपरेटरों ( & | ^) बनाम सशर्त ऑपरेटरों ( && ||) का जिक्र कर रहा है । लेकिन आप सही कह रहे हैं (निश्चित रूप से), एक तार्किक XOR है ...

— बोल्ट

14

@ बॉलकॉक: ओह, अगर सवाल यह है कि "शॉर्ट-सर्कुलेटिंग एक्सोर ऑपरेटर क्यों नहीं है?" - वहाँ कैसे हो सकता है? "और" यदि पहला तर्क गलत है, तो आपको दूसरे का मूल्यांकन करने की आवश्यकता नहीं है। "या" के साथ, यदि पहला तर्क सत्य है तो आपको दूसरे का मूल्यांकन करने की आवश्यकता नहीं है। आपको हमेशा एक्सोर के लिए दोनों तर्कों का मूल्यांकन करने की आवश्यकता होती है, इसलिए कोई छोटा सर्कुलेशन संभव नहीं है।

— एरिक लिपर्ट

4

प्रश्न स्वयं Microsoft के लिए एक बेहतर अनुकूल है - और इसलिए यह डाउनवोट करने का एक सभ्य कारण है - लेकिन अगर किसी ने इसे डाउनवोट किया है तो ^ ऑपरेटर के कारण, तो आपको विस्तार से अधिक ध्यान देने की आवश्यकता है, क्योंकि प्रश्न सशर्त था। तार्किक, बस "क्यों नहीं एक XOR है"।

— ईविल यूनानो

121

C # में, सशर्त संचालक आवश्यक होने पर केवल अपने द्वितीयक ऑपरेंड को निष्पादित करते हैं ।

चूंकि XOR को दोनों मूल्यों की परिभाषा का परीक्षण करना चाहिए , एक सशर्त संस्करण मूर्खतापूर्ण होगा।

उदाहरण :

तार्किक और: &- हर बार दोनों पक्षों का परीक्षण करता है।
तार्किक OR: |- हर बार दोनों पक्षों का परीक्षण करें।
सशर्त और: &&- केवल 2 पक्ष का परीक्षण करता है यदि 1 पक्ष सत्य है।
सशर्त या: ||- केवल दूसरी तरफ का परीक्षण करें यदि 1 पक्ष गलत है।

— ईविल यूनानी
स्रोत

35

एक XOR संचालक सम्मेलन का उल्लंघन नहीं करेगा "सशर्त संचालक केवल यदि आवश्यक हो तो अपने माध्यमिक संचालक को निष्पादित करें"। यह हमेशा जरूरी होगा।

— नाथन कोवनर

2

सशर्त XOR कुछ विशेष पैटर्न के लिए एक अच्छा और सुरुचिपूर्ण शॉर्टकट हो सकता है, हालांकि यह सुनिश्चित नहीं है कि भाषा में इसे शामिल करने के लिए पर्याप्त उचित है। ऐसे पैटर्न का एक उदाहरण जहां XOR उपयोगी साबित हो सकता है, सशर्त नकारात्मकता है: जब एक बूलियन अभिव्यक्ति को नकार दिया जाना चाहिए या नहीं, दूसरी बूलियन अभिव्यक्ति को देखते हुए।

— साल्वाडोरगोमेज़

1

कुछ समय में इस पर प्रतिक्रिया नहीं दी गई, लेकिन @KhyadHalda की लोकप्रिय टिप्पणी का जवाब देने के लिए: आप कभी कुछ ऐसा क्यों बनाएंगे जिसे आप जानते हैं कि इसका उपयोग कभी नहीं किया जाएगा? आप जानबूझकर डेड कोड लिख रहे होंगे।

— ईविल यूनान

यह देखते हुए कि एक सशर्त XOR संचालक आपके द्वारा परिभाषित किए गए कन्वेंशन (ख़याद की टिप्पणी) का उल्लंघन नहीं करेगा, इस तथ्य के साथ युग्मित कि यह वास्तव में कुछ मामलों में उपयोगी होगा, यह किसी भी "निष्ठा" की उपेक्षा करता है जिसे आप ऐसे ऑपरेटर को बताते हैं।

— सिंडंड

1

कैसे, कभी, एक सशर्त XOR कभी उपयोगी होगा? एक सशर्त XOR दोनों पक्षों की तुलना किए बिना यह निर्धारित करने के लिए कभी भी मूल्यांकन नहीं कर सकता है कि वे समान हैं या नहीं हैं। यहां तक कि दो बूल की तुलना करने वाले सशर्त XOR की धारणा को अभी भी प्रत्येक बूल के मूल्य की जांच करनी चाहिए और समानता का परीक्षण करना चाहिए।

— ईविल यूनान

280

सवाल थोड़ा पुराना है लेकिन ...

यह है कि इस ऑपरेटर को कैसे काम करना चाहिए:

true xor false = true
true xor true = false
false xor true = true
false xor false = false

यह है! = ऑपरेटर बूल प्रकार के साथ काम करता है:

(true != false) // true
(true != true) // false
(false != true) // true
(false != false) // false

तो जैसा कि आप देख रहे ^^हैं कि मौजूदा के साथ बदल दिया जा सकता है!=

— piotrpo
स्रोत

46

यह वास्तव में एकमात्र उत्तर है जो प्रश्न को सीधे और सही तरीके से संबोधित करता है।

— मारी

39

मैं यहाँ खुद सामना कर रहा हूँ कि मुझे एहसास नहीं था कि !=इसके लिए काम करेंगे।

— एडमएमसी 331

1

उत्तर सही है लेकिन टिप्पणी नहीं है। यह प्रश्न को संबोधित नहीं करता है, जो "क्यों नहीं है C # एक सशर्त XOR है?"। कड़ाई से बोलते हुए यह एक तार्किक ऑपरेटर नहीं है, यह एक संबंधपरक समानता ऑपरेटर है। जबकि परिणाम XOR के समान है, यह एक अलग वर्ग में है। दो बूलियन मूल्यों का परीक्षण करते समय यह केवल XOR से तुलना करता है, और ऑपरेटर के दोनों किनारों का अभी भी मूल्यांकन किया जाना चाहिए।

— ईविल ग्रीबो ने

3

@ TheEvilGreebo - आप जो कहते हैं वह सच है; ! = ऑपरेटर तकनीकी रूप से एक सशर्त XOR ऑपरेटर नहीं है। हालाँकि, यह उत्तर प्रभावी रूप से कहता है, "एक सशर्त XOR ऑपरेटर मौजूद नहीं है क्योंकि! = ऑपरेटर करता है।" वैसे भी मैंने इसे पढ़ा है।

— सिंडंड

6

मुझे लगता है कि बहुत ज्यादा हर एक ने इस पोस्ट को समाप्त कर दिया, वास्तव में बूलियंस पर XOR लिखना चाहता था। जैसे तार्किक है ANDऔर ORजैसा कुछ भी नहीं है XOR। या कम से कम हमें एहसास नहीं था !=:) @EvilGreebo

— M.kazem Akhgary

30

तार्किक XOR ऑपरेटर है: ^

प्रलेखन: सी # ऑपरेटरों और ^ ऑपरेटर

— iceaway
स्रोत

2

तार्किक, सशर्त नहीं। तार्किक और = &, सशर्त और = &&। वह कंडिशनल के बारे में पूछ रहा है।

— ईविल यूनानो

3

यह बाइनरी है, तार्किक नहीं। यह मानता है कि बूल 0 या 1 हैं जो सीएलआर पर सच नहीं हैं।

— मारी

1

क्षमा करें, यह उत्तर वास्तव में CONDITIONAL ऑपरेटरों के बारे में प्रश्न का उत्तर नहीं देता है। यह थोड़ा अफीमदार है

— नाथन ट्रेगिलस

2

रिकॉर्ड के लिए, इस उत्तर में जुड़ा हुआ दस्तावेज स्पष्ट रूप से बताता है कि ^, जब बूलियन ऑपरेंड के साथ प्रयोग किया जाता है , तो बूलियन ऑपरेटर होता है। "बूल ऑपरेंड के लिए, ^ ऑपरेटर असमानता ऑपरेटर के समान परिणाम की गणना करता है! ="। आप बिटवाइर-एक्सर पूर्णांक ऑपरेंड के साथ भी कर सकते हैं ^। C # नहीं है C.

— 15ee8f99-57ff-4f92-890c-b56153

24

एक स्पष्टीकरण के रूप में, ^ ऑपरेटर अभिन्न प्रकार और बूल दोनों के साथ काम करता है।

MSDN के ^ ऑपरेटर देखें (C # संदर्भ) :

बाइनरी ^ ऑपरेटरों को अभिन्न प्रकार और बूल के लिए पूर्वनिर्धारित किया जाता है। अभिन्न प्रकारों के लिए, ^ अपने ऑपरेंड के बिटवाइज अनन्य-OR की गणना करता है। बूल ऑपरेंड के लिए, ^ तार्किक अनन्य-या उसके ऑपरेंड की गणना करता है; यही कारण है कि, परिणाम सच है अगर और केवल अगर उसके ऑपरेंड में से एक सच है।

हो सकता है कि यह सवाल पूछे जाने के बाद 2011 से प्रलेखन बदल गया हो।

— RichardCL
स्रोत

2

एक लंबे समय में c # प्रोग्रामिंग किया गया है, यह कभी नहीं पता था! धन्यवाद @ रायचर्ड!

— नाथन ट्रेगिलस

यह अच्छी जानकारी है, लेकिन एक टिप्पणी के रूप में अधिक उपयुक्त लगती है या अन्य उत्तर को संपादित करती है जो ^पांच साल तक इस का उल्लेख और पूर्वसूचक करती है। मुझे संदेह है कि कुछ भी बदल गया है।

— क्रिस

13

जैसा कि मार्क एल ने पूछा है , यहां सही संस्करण है:

 Func<bool, bool, bool> XOR = (X,Y) => ((!X) && Y) || (X && (!Y));

यहाँ सत्य सारणी है:

 X | Y | Result
 ==============
 0 | 0 | 0
 1 | 0 | 1
 0 | 1 | 1
 1 | 1 | 0

संदर्भ: विशेष या

— सरल साथी
स्रोत

2

पूछा गया सवाल यह है कि C # के पास सशर्त XOR ऑपरेटर क्यों नहीं है। इस सवाल का जवाब नहीं है। फ़ंक्शन के रूप में: यह फ़ंक्शन सशर्त XOR के रूप में कार्य करता है - हालांकि सवाल यह है कि क्या यह गैर-सशर्त XOR से अधिक कुशल है? अनन्य सत्य के लिए परीक्षण करने के लिए, XOR को यह पुष्टि करनी चाहिए कि एक और वास्तव में एक परिणाम सत्य है। इसका अर्थ है कि दोनों पक्षों का मूल्यांकन और तुलना की जानी चाहिए। ऊपर दिए गए फ़ंक्शन, न्यूनतम पर, एक मान प्राप्त करते हुए दोनों पक्षों की स्थिति का परीक्षण करते हैं। क्या हम आंतरिक रूप से जानते हैं कि क्या यह XOR से अलग है?

— ईविल यूनान

6

अरे हाँ, यह करता है।

bool b1 = true;
bool b2 = false;
bool XOR = b1 ^ b2;

— आर्मेन त्सिरुयन
स्रोत

1

यह एक द्विआधारी ऑपरेटर है, न कि तार्किक। यह मानता है कि बूल 0 या 1 हैं जो सीएलआर पर सच नहीं हैं। तो यह कोड वास्तव में काम करने में विफल हो सकता है।

— usr

6

@usr, C # में, दो बूलियन ऑपरेंड पर लागू होने पर ^ ऑपरेटर तार्किक है। आपने इन उत्तरों के माध्यम से एक भयानक टिप्पणी की, क्या आपने कभी अपनी परिकल्पना का परीक्षण करने के लिए कोई कोड चलाया?

— मार्क एल।

2

@MarcL। मैंने किया: pastebin.com/U7vqpn6G प्रिंट्स सच है, हालांकि सच ^ सच को गलत माना जाता है। बूल हमेशा 0 या 1 के बराबर नहीं होता है। यह CLR पर तार्किक प्रकार नहीं है। यह मनमानी सामग्री के साथ एक 8 बिट मात्रा है। मैं इस मुद्दे को प्रदर्शित करने के लिए सत्यापित आईएल उत्पन्न कर सकता था।

— usr

2

उदाहरण के लिए C # के अलावा अन्य CLR भाषाओं का उपयोग करते समय। मैं दोहराता हूं: मैं ILASM का उपयोग पूरी तरह से सत्यापित करने योग्य, सुरक्षित असेंबली बनाने के लिए कर सकता था जो ऐसा करता है (IL स्तर पर बूलियन मान i1बस एक बाइट की तरह है)। यह 100% परिभाषित और सुरक्षित प्रबंधित व्यवहार है। सीएलआर रफ-अप नहीं है ।; Microsoft Pex का उपयोग करते समय मैंने पहली बार यह व्यवहार देखा था।

— usr

1

@EdPlunkett, मुझे नहीं लगता कि आपका ट्रक मेरे साथ है। usr ने दिखाया कि आंतरिक रूप से यह वास्तव में एक द्विआधारी ऑपरेटर है। "दुर्व्यवहार" जिसकी मैंने शिकायत की थी वह साधन था जिसके द्वारा उसने इसे साबित कर दिया था, जिसे मैं अभी भी बनाए रखता हूं। यह हो सकता है, लेकिन बूलियन का उपयोग पूरी तरह से नो-मैन की भूमि में करता है जो इसे सीएलआर-सुरक्षित के रूप में तैनात करने के लिए सबसे अच्छा, खतरनाक (यदि दुर्भावनापूर्ण नहीं है) सबसे खराब रूप में खतरनाक होगा, और इसे बग के रूप में माना जाना चाहिए। Usr जो साबित करता है कि आंतरिक सी # हम दोनों के विचार से अधिक सी है। क्या ऐसा करने वाला कोड वैध माना जाना चाहिए यह एक और सवाल है।

— मार्क एल

4

सशर्त एक्सोर मौजूद नहीं है, लेकिन आप तार्किक का उपयोग कर सकते हैं क्योंकि एक्सर को बुलियन के लिए परिभाषित किया गया है, और सभी सशर्त तुलना बूलियन का मूल्यांकन करते हैं।

तो आप कुछ ऐसा कह सकते हैं:

if ( (a == b) ^ (c == d))
{

}

— Klark
स्रोत

यह एक द्विआधारी ऑपरेटर है, न कि तार्किक। यह मानता है कि बूल 0 या 1 हैं जो सीएलआर पर सच नहीं हैं। तो यह कोड वास्तव में काम करने में विफल हो सकता है।

— usr

@usr आप सीएलआर का क्या मतलब है? यह मेरे लिए काम कर रहा था, यकीन नहीं होता कि मैं यहां एक किनारे का मामला याद करता ...

— LunaCodeGirl

3

@Spencevail शायद आप इस मामले के बारे में नहीं सोच रहे थे कि एक गैर-झूठे बूलियन में पूर्णांक प्रतिनिधित्व नहीं हो सकता है 1। यह थोड़ा ज्ञात तथ्य है। आप एक ऐसी स्थिति में समाप्त हो सकते हैं, जहां दो गैर-झूठे बूलियंस के एक्सर अभी भी गैर-झूठे हैं! इस विशेष कोड में कहा गया है कि xor ऑपरेटर केवल [0,1] में मूल्यों पर लागू होता है ताकि मेरी टिप्पणी पूरी तरह से लागू न हो।

— usr

1

@Spencevail जो वास्तव में विफल हो सकता है। एक सुरक्षित प्रबंधित कोड फ़ंक्शन CreateBool (बाइट) बनाना संभव है जो एक बाइट को समान बिट्स के बूल में परिवर्तित करता है। फिर, CreateBool (1) ^ CreateBool (2) सत्य है, लेकिन CreateBool (1) सत्य है और CreateBool (2) भी सत्य है! &कमजोर भी है।

— यूआर

1

वास्तव में, मैंने सिर्फ एक RyuJIT बग की सूचना दी क्योंकि वे इस संभावना पर विचार नहीं &&करते थे और संकलित करते थे जैसे कि यह &एक गलत बयान है।

— यूआर

3

जबकि लॉजिकल एक्सोर ऑपरेटर है ^, कोई सशर्त एक्सोर ऑपरेटर नहीं है। आप निम्नलिखित का उपयोग करके A और B दो मानों का एक सशर्त xor प्राप्त कर सकते हैं:

A ? (!B) : B

पैरेंस आवश्यक नहीं हैं, लेकिन मैंने उन्हें स्पष्टता के लिए जोड़ा।

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

— jimreed
स्रोत

एक लॉजिक ^ और एक सशर्त ^ के बीच क्या अंतर है? oO

— अरमान त्सिरुयन

@Armen Tsirunyan तार्किक ऑपरेटर उन प्रकारों में बिटवाइज़ ऑपरेशंस करते हैं, जो समझ में आता है जबकि सशर्त ऑपरेटर बूलियन मानों पर काम करते हैं और बूलियन परिणाम देते हैं। बूलियन मूल्यों को ध्यान में रखते हुए: 0101 ^ 0011मूल्य है 0110।

— बजे

3

नहीं, आप पूरी तरह से गलत हैं। COR में दोनों प्रकार के XOR हैं (उन्हें क्रमशः बिटवाइज़ और लॉजिकल कहा जाता है)। दोनों ^ प्रतीक का उपयोग करते हैं।

— बजे आर्मेन त्सिरुयान

1

आप उपयोग कर सकते हैं:

a = b ^ c;

जैसे c / c ++ में

— gulyan
स्रोत

0

सशर्त (शॉर्ट-सर्किटिंग) एक्सओआर जैसी कोई चीज नहीं है। सशर्त संचालक केवल तभी सार्थक होते हैं जब निश्चित रूप से केवल पहले तर्क को देखने से अंतिम परिणाम बताने का एक तरीका होता है। XOR (और जोड़) को हमेशा दो तर्कों की आवश्यकता होती है, इसलिए पहले तर्क के बाद शॉर्ट-सर्किट का कोई रास्ता नहीं है।

यदि आप A = true जानते हैं, तो (A XOR B) =! B

यदि आप A = गलत जानते हैं, तो (A XOR B) = B

दोनों ही मामलों में, यदि आप A को जानते हैं, लेकिन B को नहीं, तो आप पर्याप्त नहीं जानते (A XOR B)। उत्तर की गणना करने के लिए आपको ए और बी दोनों के मूल्यों को हमेशा सीखना चाहिए। शाब्दिक रूप से कोई उपयोग का मामला नहीं है जहां आप कभी भी दोनों मूल्यों के बिना XOR को हल कर सकते हैं।

ध्यान रखें, XOR परिभाषा के अनुसार चार मामले हैं:

false xor true  = true
true  xor false = true
true  xor true  = false
false xor false = false

फिर, उम्मीद है कि ऊपर से यह स्पष्ट है कि पहला मूल्य जानना कभी पर्याप्त नहीं है दूसरा उत्तर जानने के बिना भी उत्तर प्राप्त करने के लिए पर्याप्त नहीं है। हालाँकि, आपके प्रश्न में, आपने पहले मामले को छोड़ दिया। अगर आप इसके बजाय चाहते थे

false op true  = false (or DontCare)
true  op false = true
true  op true  = false
false op false = false

तब आप वास्तव में एक छोटी-परिचालित सशर्त ऑपरेशन द्वारा प्राप्त कर सकते हैं:

A && !B

लेकिन यह एक XOR नहीं है।

— केविन होल्ट
स्रोत

मैं इस उत्तर में कुछ भी नहीं देख रहा हूँ जो कि कम से कम एक उत्तर में नहीं है। मुझे ऐसा कोई संकेत नहीं दिख रहा है कि आपका शॉर्ट-सर्कुलेटिंग अन-एक्सर वही है जो ओपी देख रहा था, क्योंकि उसने एक जवाब स्वीकार किया था जो मानता है कि वह उचित एक्सर चाहता था।

— 15ee8f99-57ff-4f92-890c-b56153

मेरा शाब्दिक रूप से अब तक का एकमात्र उत्तर है जो दूसरे तर्क का मूल्यांकन किए बिना ओपी के अनुरोधित सत्य तालिका का उत्पादन कर सकता है।

— केविन होल्ट

साथ ही ओपी ने पूछा कि कोई सशर्त XOR क्यों नहीं है, और जबकि ऊपर दिए गए उत्तर सही ढंग से कहते हैं कि ऐसा इसलिए है क्योंकि XOR को दो तर्कों की आवश्यकता होती है, IMO ऊपर दिए गए उत्तरों को यह स्पष्ट रूप से नहीं बताता है कि क्यों XOR को वास्तव में दो तर्कों की आवश्यकता है। स्पष्ट रूप से आप अन्यथा महसूस करते हैं, लेकिन मेरे लिए इस पृष्ठ पर विभिन्न टिप्पणियों से यह स्पष्ट था कि XOR की बुनियादी दो-तर्क पूर्ण शुरुआत को अभी तक पूरी तरह से समझाया नहीं गया था।

— केविन होल्ट

1

आपने मुझसे इसमें बात की।

— 15ee8f99-57ff-4f92-890c-b56153

@ केविन होल्ट - लॉजिकल एक्सओआर सार्थक है अगर आपको सही परिस्थितियों में से एक की जरूरत है लेकिन दोनों की नहीं। कि आपको दोनों स्थितियों का मूल्यांकन करना होगा कोई फर्क नहीं पड़ता। शॉर्ट सर्किट चीज़ एक निम्न स्तर का विवरण है जिसे आपको केवल प्रदर्शन के महत्वपूर्ण कोड से निपटने के बारे में चिंता करनी होगी (नियंत्रण प्रवाह धीमा है)। मैं इस बात से अधिक चिंतित हूँ कि किसी तार्किक ऑपरेटर को इससे बाहर निकालते समय 'अनन्य या' का क्या अर्थ है। अर्थात्, यह बिटवाइज़ संस्करण की तरह काम करता है (अन्य ऑपरेटरों की तरह), या इसे एक या ऐसा अनन्य बनाएं (जितनी चाहें उतनी शर्तें, लेकिन केवल एक ही सच हो सकता है)।

— थोरम

-3

इस सवाल का उत्तर दिया गया है, लेकिन मैं एक अलग स्थिति में आया हूं। यह सच है कि सशर्त XOR की कोई आवश्यकता नहीं है। यह भी सही है कि ^ ऑपरेटर का उपयोग किया जा सकता है। हालांकि, यदि आपको केवल ऑपरेंड्स की "सही" झूठी "स्थिति का परीक्षण करने की आवश्यकता है तो ^ परेशानी पैदा कर सकता है।" उदाहरण के लिए:

void Turn(int left, int right)
{
    if (left ^ right)
    {
        //success... turn the car left or right...
    }
    else
    {
        //error... no turn or both left AND right are set...
    }
}

इस उदाहरण में, यदि बाईं ओर 10 (0xa) पर सेट किया गया है और दाईं ओर 5 (0x5) पर सेट किया गया है, तो "सफलता" शाखा में प्रवेश किया जाता है। इसके लिए (सरलीकृत अगर मूर्खतापूर्ण) उदाहरण है, तो यह बग के परिणामस्वरूप होगा क्योंकि आपको एक ही समय में बाएं और दाएं मुड़ना नहीं चाहिए। मैंने प्रश्नकर्ता से जो इकट्ठा किया, वह यह नहीं है कि वह वास्तव में एक सशर्त चाहता था, लेकिन मानों पर सही / गलत प्रदर्शन करने का एक सरल तरीका है जैसा कि एक्सर को दिया गया था।

एक मैक्रो कर सकता है चाल:

#define my_xor(a, b) ( ((a)?1:0) ^ ((b)?1:0) )

अगर मैं निशान से दूर हूँ तो मुझे बेझिझक थप्पड़ मारो: ओ)

मैंने यह पोस्ट करने के बाद नीचे jimreed का उत्तर पढ़ा (बुरा यापदोग!) और उसका वास्तव में सरल है। यह काम करेगा और मुझे इस बात का बिलकुल भी अंदाजा नहीं है कि उसका जवाब क्यों दिया गया ...

— याप डॉग
स्रोत

3

यह C # प्रश्न है, C / C ++ नहीं। ifएक बूलियन अभिव्यक्ति की आवश्यकता है, यह एक इंट के साथ भी संकलित नहीं करेगा।

— मार्क एल।