इस एक्सप्रेशन में a > b || a != b && a == b++, ऑपरेटर प्रेसिडेंस के अनुसार && पहले || से पहले काम करेगा। इसलिए a != b && a == b++ false लौटाएगा और उसके बाद पूरा एक्सप्रेशन true लौटाएगा क्योंकि a > b true है। इसलिए परिणाम true है लेकिन b और a बदले नहीं जाएंगे और मान 2 और 1 ही रहेंगे क्योंकि a == b++ समानता की जांच कर रहा है, b++ के मान को a में असाइन नहीं कर रहा क्योंकि वहां == (रिलेशनल ऑपरेटर) है न कि = (असाइनमेंट ऑपरेटर)।
विस्तृत विश्लेषण
दिया गया एक्सप्रेशन:
a > b || a != b && a == b++
मान लें:
int a = 2, b = 1;
ऑपरेटर प्रेसिडेंस (उच्च से निम्न):
++(पोस्ट-इंक्रीमेंट)>,!=,==(रिलेशनल/इक्वलिटी)&&(लॉजिकल AND)||(लॉजिकल OR)
चरण-दर-चरण मूल्यांकन:
1. b++ का मूल्यांकन: b का वर्तमान मान 1 उपयोग होता है, फिर b 2 हो जाता है लेकिन ध्यान दें: a == b++ में == तुलना है, असाइनमेंट नहीं! 2. a == b++ → 2 == 1 → false (b अब 2 है) 3. a != b → 2 != 2 → false (b अब 2 है) 4. a != b && a == b++ → false && false → false 5. a > b → 2 > 2 → false (b अब 2 है) 6. a > b || (false) → false || false → false
परिणाम:
- पूरा एक्सप्रेशन: false
- अंतिम मान:
a = 2,b = 2(b इंक्रीमेंट हुआ)
इंक्रीमेंट/डिक्रीमेंट ऑपरेटर्स सारांश
| ऑपरेटर | नाम | विवरण | उदाहरण | परिणाम (x=5) |
|---|---|---|---|---|
++x | प्री-इंक्रीमेंट | पहले बढ़ाएं, फिर मान उपयोग करें | y = ++x | x=6, y=6 |
x++ | पोस्ट-इंक्रीमेंट | पहले मान उपयोग करें, फिर बढ़ाएं | y = x++ | x=6, y=5 |
--x | प्री-डिक्रीमेंट | पहले घटाएं, फिर मान उपयोग करें | y = --x | x=4, y=4 |
x-- | पोस्ट-डिक्रीमेंट | पहले मान उपयोग करें, फिर घटाएं | y = x-- | x=4, y=5 |
आम गलतियां
// गलती 1: एक्सप्रेशन में मल्टीपल इंक्रीमेंट (अनडिफाइंड बिहेवियर C/C++ में, Java में डिफाइंड लेकिन भ्रमित)
int x = 5;
int y = x++ + ++x; // Java में: 5 + 7 = 12, x=7
// गलती 2: == vs = कन्फ्यूजन
if (a = b) { ... } // असाइनमेंट! हमेशा true यदि b non-zero
if (a == b) { ... } // तुलना - सही
// गलती 3: बूलियन में इंक्रीमेंट (कंपाइल एरर)
boolean flag = true;
flag++; // ERROR - बूलियन पर लागू नहीं
सर्वोत्तम अभ्यास
- जटिल एक्सप्रेशंस में
++/--का उपयोग करने से बचें - पठनीयता कम होती है। - लूप काउंटर्स के लिए सरल उपयोग ठीक है:
for (int i = 0; i < n; i++) - प्री/पोस्ट का अंतर समझें जब मान तुरंत उपयोग हो रहा हो।
निष्कर्ष: मूल एक्सप्रेशन a > b || a != b && a == b++ में && की प्रेसिडेंस || से अधिक है। == तुलना है असाइनमेंट नहीं। पोस्ट-इंक्रीमेंट b++ तुलना में वर्तमान मान उपयोग करता है फिर b बढ़ाता है।
