C भाषा में मूल्यांकन किए जाने वाले एक्सप्रेशन्स के प्रकार

एक एक्सप्रेशन ऑपरेटर्स और ऑपरेंड्स का संयोजन है।

ऑपरेंड - वह डेटा आइटम जिस पर ऑपरेशन किया जाता है।
ऑपरेटर - डेटा पर ऑपरेशन करता है।

उदाहरण: z = 3 + 2 * 1 → z = 5

एक्सप्रेशन्स के प्रकार

C भाषा में मूल्यांकन किए जाने वाले विभिन्न प्रकार के एक्सप्रेशन्स:

प्रकार	विवरण	उदाहरण
प्राइमरी एक्सप्रेशन्स (Primary)	ऑपरेंड एक नाम, कॉन्स्टेंट, या पैरेंथेसाइज़्ड एक्सप्रेशन हो सकता है	`c = a + (5 * b);`
पोस्टफिक्स एक्सप्रेशन्स (Postfix)	ऑपरेटर ऑपरेंड्स के बाद आता है	`a++`, `arr[i]`, `func()`, `ptr->member`
प्रीफिक्स एक्सप्रेशन्स (Prefix)	ऑपरेटर ऑपरेंड से पहले आता है	`++a`, `--b`, `!flag`, `*ptr`, `&var`
यूनरी एक्सप्रेशन्स (Unary)	एक ऑपरेटर और एक ऑपरेंड	`a++`, `--b`, `+x`, `-y`, `~bits`
बाइनरी एक्सप्रेशन्स (Binary)	दो ऑपरेंड्स और एक ऑपरेटर	`a + b`, `c - d`, `x * y`, `p / q`
टर्नरी एक्सप्रेशन्स (Ternary)	तीन ऑपरेंड्स और एक ऑपरेटर (केवल `?:`)	`exp1 ? exp2 : exp3` - यदि exp1 सत्य तो exp2, अन्यथा exp3

विस्तृत विवरण

1. प्राइमरी एक्सप्रेशन्स

पहचानकर्ता (वेरिएबल नाम, फंक्शन नाम)
कॉन्स्टेंट्स (इंटीजर, फ्लोटिंग, कैरेक्टर, स्ट्रिंग लिटरल्स)
स्ट्रिंग लिटरल्स
पैरेंथेसाइज़्ड एक्सप्रेशन: (a + b)
सरणी सबस्क्रिप्ट: arr[i]
फंक्शन कॉल: func(args)
मेंबर एक्सेस: obj.member, ptr->member
कंपाउंड लिटरल्स (C99): (int[]){1,2,3}

2. पोस्टफिक्स एक्सप्रेशन्स

ऑपरेटर ऑपरेंड के बाद आता है:

पोस्ट-इन्क्रीमेंट/डिक्रीमेंट: i++, i--
फंक्शन कॉल: func()
सरणी सबस्क्रिप्ट: arr[index]
स्ट्रक्चर/यूनियन मेंबर: s.member, p->member
कंपाउंड लिटरल: (type){init}

3. प्रीफिक्स/यूनरी एक्सप्रेशन्स

ऑपरेटर ऑपरेंड के पहले आता है:

प्री-इन्क्रीमेंट/डिक्रीमेंट: ++i, --i
यूनरी प्लस/माइनस: +x, -x
लॉजिकल NOT: !x
बिटवाइज NOT: ~x
एड्रेस-ऑफ: &x
डीरेफरेंस: *p
कास्ट: (type)expr
sizeof, _Alignof (C11)

4. बाइनरी एक्सप्रेशन्स

दो ऑपरेंड्स, एक ऑपरेटर (अंकगणितीय, रिलेशनल, लॉजिकल, बिटवाइज, असाइनमेंट):

a + b, a - b, a * b, a / b, a % b
a == b, a != b, a < b, a > b
a && b, a || b
a & b, a | b, a ^ b
a = b, a += b, आदि

5. टर्नरी एक्सप्रेशन

C में एकमात्र टर्नरी ऑपरेटर ?: है:

condition ? expr_if_true : expr_if_false

उदाहरण प्रोग्राम

#include <stdio.h> 

int main() {
    int a = 10, b = 5;
    
    // टर्नरी एक्सप्रेशन
    int max = (a > b) ? a : b;
    printf("Max: %d\n", max);
    
    // नेस्टेड टर्नरी
    int sign = (a > 0) ? 1 : (a < 0) ? -1 : 0;
    printf("Sign of a: %d\n", sign);
    
    // पोस्टफिक्स
    int i = 5;
    printf("i++ = %d, i = %d\n", i++, i);  // 5, 6
    
    // प्रीफिक्स
    int j = 5;
    printf("++j = %d, j = %d\n", ++j, j);  // 6, 6
    
    // बाइनरी
    printf("a + b = %d\n", a + b);
    printf("a - b = %d\n", a - b);
    
    return 0;
}

आउटपुट

Max: 10
Sign of a: 1
i++ = 5, i = 6
++j = 6, j = 6
a + b = 15
a - b = 5

महत्वपूर्ण नोट

मूल पाठ में "Postfix: ab+" और "Prefix: +ab" दिखाया गया है जो पोस्टफिक्स/प्रीफिक्स नोटेशन (रिवर्स पोलिश नोटेशन) है, न कि C सिंटैक्स। C में पोस्टफिक्स/प्रीफिक्स ऑपरेटर्स ऑपरेंड के सापेक्ष स्थिति दर्शाते हैं (ऊपर देखें)।