एक्सप्रेशन्स का मूल्यांकन 'C' कंपाइलर द्वारा प्रीसिडेंस (प्राथमिकता) और एसोसिएटिविटी (साहचर्य) नियमों के आधार पर किया जाता है।
यदि एक एक्सप्रेशन में अलग-अलग प्राथमिकता के ऑपरेटर्स हैं, तो प्रीसिडेंस नियमों पर विचार किया जाता है।
उदाहरण: a = 10 - 2 * 5
यहां, 2 * 5 पहले मूल्यांकित होता है क्योंकि * की प्राथमिकता - और = से अधिक है।
परिणाम: a = 10 - 10 = 0
यदि एक एक्सप्रेशन में समान प्राथमिकता के ऑपरेटर्स हैं, तो एसोसिएटिविटी नियमों पर विचार किया जाता है (बाएं से दाएं या दाएं से बाएं)।
ऑपरेटर प्रीसिडेंस और एसोसिएटिविटी तालिका
| प्रीसिडेंस | ऑपरेटर्स | एसोसिएटिविटी | विवरण |
|---|---|---|---|
| 1 (उच्चतम) | () [] -> . ++ -- (पोस्टफिक्स) | बाएं से दाएं | फंक्शन कॉल, सरणी सबस्क्रिप्ट, मेंबर एक्सेस, पोस्ट-इन्क्रीमेंट |
| 2 | ++ -- + - ! ~ * & (टाइप) sizeof (प्रीफिक्स/यूनरी) | दाएं से बाएं | प्री-इन्क्रीमेंट, यूनरी प्लस/माइनस, लॉजिकल NOT, बिटवाइज NOT, डीरेफरेंस, एड्रेस-ऑफ, कास्ट |
| 3 | * / % | बाएं से दाएं | गुणात्मक |
| 4 | + - | बाएं से दाएं | योजक |
| 5 | << >> | बाएं से दाएं | बिटवाइज शिफ्ट |
| 6 | < <= > >= | बाएं से दाएं | रिलेशनल |
| 7 | == != | बाएं से दाएं | समानता |
| 8 | & | बाएं से दाएं | बिटवाइज AND |
| 9 | ^ | बाएं से दाएं | बिटवाइज XOR |
| 10 | | | बाएं से दाएं | बिटवाइज OR |
| 11 | && | बाएं से दाएं | लॉजिकल AND |
| 12 | || | बाएं से दाएं | लॉजिकल OR |
| 13 | ?: | दाएं से बाएं | टर्नरी कंडीशनल |
| 14 | = += -= *= /= %= &= ^= |= <<= >>= | दाएं से बाएं | असाइनमेंट |
| 15 (निम्नतम) | , | बाएं से दाएं | कॉमा ऑपरेटर |
मूल्यांकन क्रम के उदाहरण
उदाहरण 1: मिश्रित प्रीसिडेंस
int x = 10 + 20 * 30 - 40 / 5; // चरण 1: 20 * 30 = 600 (उच्चतम प्रीसिडेंस *) // चरण 2: 40 / 5 = 8 (/ की प्रीसिडेंस * के समान, बाएं से दाएं) // चरण 3: 10 + 600 = 610 (+ की प्रीसिडेंस कम) // चरण 4: 610 - 8 = 602 // परिणाम: x = 602
उदाहरण 2: समान प्रीसिडेंस, बाएं से दाएं एसोसिएटिविटी
int x = 100 - 20 - 10; // (100 - 20) - 10 = 80 - 10 = 70 // नहीं: 100 - (20 - 10) = 90
उदाहरण 3: असाइनमेंट - दाएं से बाएं एसोसिएटिविटी
int a, b, c; a = b = c = 10; // c = 10 // b = c = 10 // a = b = 10 // सभी 10 हो जाते हैं
उदाहरण 4: टर्नरी ऑपरेटर - दाएं से बाएं
int x = 1, y = 2, z = 3; int result = x ? y : z; // x सत्य (1) है, इसलिए result = y = 2 // नेस्टेड टर्नरी: int max = a > b ? a : b > c ? b : c; // पार्स होता है: a > b ? a : (b > c ? b : c)
उदाहरण 5: प्रीफिक्स vs पोस्टफिक्स
int a = 5; int b = ++a + a++; // अनिर्दिष्ट व्यवहार! एक ही एक्सप्रेशन में एक ही वेरिएबल मॉडिफाई और रीड करना // C मानक: अनिर्दिष्ट व्यवहार - कंपाइलर पर निर्भर
पैरेंथेसिस का उपयोग
स्पष्टता के लिए और इच्छित क्रम लागू करने के लिए पैरेंथेसिस का उपयोग करें:
// अस्पष्ट: x = a + b * c - d / e; // स्पष्ट: x = a + (b * c) - (d / e); // या इच्छित क्रम लागू करने के लिए: x = (a + b) * (c - d) / e;
सर्वोत्तम अभ्यास
- संदेह होने पर पैरेंथेसिस का उपयोग करें - यह पठनीयता में सुधार करता है और बग्स रोकता है।
- एक ही एक्सप्रेशन में एक ही वेरिएबल को मॉडिफाई और रीड न करें (अनिर्दिष्ट व्यवहार)।
- कॉम्प्लेक्स एक्सप्रेशन्स को सरल स्टेटमेंट्स में तोड़ें।
- कंपाइलर चेतावनियां सक्षम करें (
-Wall -Wextra)।