एक ऑपरेटर एक प्रतीक है जो संकलक को विशिष्ट गणितीय या तार्किक जोड़-तोड़ करने के लिए कहता है।
C भाषा में निम्नलिखित ऑपरेटर होते हैं:
Arithmetic Operators (अंकगणितीय ऑपरेटर):
(जोड़), - (घटाव), * (गुणा), / (भाग), % (भागफल)
Relational Operators (संबंधात्मक ऑपरेटर):
== (बराबर), != (बराबर नहीं), > (अधिकतम), < (न्यूनतम),
>= (अधिकतम या बराबर), <= (न्यूनतम या बराबर)
Logical Operators (तार्किक ऑपरेटर):
&& (तथा), || (अथवा), ! (नहीं)
Assignment Operators (असाइनमेंट ऑपरेटर):
= (असाइन), += (जोड़कर असाइन), -= (घटाकर असाइन),
*= (गुणाकर असाइन), /= (भागकर असाइन),
%= (भागफल के साथ असाइन)
Increment/Decrement Operators (इन्क्रीमेंट/डिक्रीमेंट ऑपरेटर):
++ (इन्क्रीमेंट), -- (डिक्रीमेंट)
Bitwise Operators (बिटवाइज ऑपरेटर):
& (बिटवाइज और), | (बिटवाइज या), ^ (बिटवाइज अक्षरवर्ती),
~ (बिटवाइज नॉट), << (बिट शिफ्ट बाएं), >> (बिट शिफ्ट दाएं)
इन सभी ऑपरेटरों का उपयोग C भाषा में विभिन्न ऑपरेशनों के लिए किया जाता है।
अगर हम C भाषा के ऑपरेटर के उदाहरण देखें तो निम्नलिखित होंगे:
Arithmetic Operators:
जोड़ (+): यदि हम दो संख्याओं को जोड़ना चाहते हैं, तो उन दो संख्याओं के बीच "+" ऑपरेटर का उपयोग करें।
उदाहरण:
int a = 5, b = 10, c;
c = a + b;
यहां, c की मान 15 होगी।
घटाव (-): यदि हम दो संख्याओं को घटाना चाहते हैं, तो उन दो संख्याओं के बीच "-" ऑपरेटर का उपयोग करें।
उदाहरण:
int a = 10, b = 5, c;
c = a - b;
यहां, c की मान 5 होगी।
गुणा (): यदि हम दो संख्याओं को गुणा करना चाहते हैं, तो उन दो संख्याओं के बीच "" ऑपरेटर का उपयोग करें।
उदाहरण:
int a = 5, b = 10, c;
c = a * b;
यहां, c की मान 50 होगी।
भाग (/): यदि हम दो संख्याओं को भाग करना चाहते हैं, तो उन दो संख्याओं के बीच "/" ऑपरेटर का उपयोग करें।
उदाहरण:
float a = 10.0, b = 5.0, c;
c = a / b;
यहां, c की मान 2.0 होगी।
भागफल (%): यदि हम एक संख्या को दूसरी संख्या से भाग करते हैं, तो हम उन दो संख्याओंके शेष भाग को देखते हैं:
उदाहरण:
float a = 10.0, b = 3.0, c;
c = a % b;
यहां, c की मान 1.0 होगी।
Assignment Operators:
एकल (=): एकल ऑपरेटर का उपयोग एक मान को एक वेरिएबल में भेजने के लिए किया जाता है।
उदाहरण:
int a = 5;
यहां, a की मान 5 होगी।
जोड़ एवं (=) (+=): जोड़ एवं एकल ऑपरेटर का उपयोग दो संख्याओं को जोड़ने और पहली संख्या के वेरिएबल में उपलब्ध मान को जोड़े हुए मान से अद्यतन करने के लिए किया जाता है।
उदाहरण:
int a = 5, b = 10;
a += b;
यहां, a की मान 15 होगी।
घटाव एवं (=) (-=): घटाव एवं एकल ऑपरेटर का उपयोग दो संख्याओं को घटाने और पहली संख्या के वेरिएबल में उपलब्ध मान से घटाए हुए मान से अद्यतन करने के लिए किया जाता है।
उदाहरण:
int a = 10, b = 5;
a -= b;
यहां, a की मान 5 होगी।
गुणा एवं (=) (*=): गुणा एवं एकल ऑपरेटर का उपयोग दो संख्याओं को गुणा करने और पहली संख्या के वेरिएबल में उपलब्ध मान से गुणित मान से अद्यतन करने के लिए किया जाता है।
उदाहरण:
int a = 5, b = 10;
a *= b;
यहां, a की मान 50 होगी।
भाग एवं (=) (/=): भाग एवं एकल ऑपरेटर का उपयोग दो संख्याओं को भाग करने और पहली संख्या के वेरिएबल में उपलब्ध मान से भागित मान से अद्यतन करने के लिए किया जाता है।
उदाहरण:
int a = 10, b = 2;
a /= b;
यहां, a की मान 5 होगी।
मोडुलस एवं (=) (%=): मोडुलस एवं एकल ऑपरेटर का उपयोग दो संख्याओं का मोडुलस निकालने और पहली संख्या के वेरिएबल में उपलब्ध मान को मोडुलस मान से अद्यतन करने के लिए किया जाता है। मोडुलस ऑपरेटर का उपयोग शेषभाग की गणना के लिए किया जाता है।
उदाहरण:
int a = 10, b = 3;
a %= b;
यहां, a की मान 1 होगी।
Conditional Operators:
टर्नरराइट (?) ऑपरेटर: टर्नरराइट (?) ऑपरेटर तीन ऑपरेंड लेता है और पहला ऑपरेंड एक संख्या होता है जो टेस्ट के लिए होता है। दूसरा और तीसरा ऑपरेंड स्टेटमेंट होते हैं जो चयनित होते हैं और यह आधार पर होता है कि पहला ऑपरेंड सच है या नहीं।
उदाहरण:
int a = 10, b = 5;
int max = (a > b) ? a : b;
यहां, max की मान 10 होगी। चयनित स्टेटमेंट वास्तविकता में सच होने पर पहले ऑपरेंड से वापस लौटता है, और अन्यथा दूसरा ऑपरेंड वापस लौटता है।
लॉजिकल एंड (&&) ऑपरेटर: यह दो बूलीय एक्सप्रेशन्स के लिए उपयोग किया जाता है और यदि दोनों सच होते हैं तो एक सच मान लौटाता है। अन्यथा, अगला सच नहीं होता है।
उदाहरण:
int a = 10, b = 5;
if (a > b && b > 0)
printf("Both conditions are true");
यहां, दोनों शर्तें सच हैं, इसलिए "Both conditions are true" लाइन मुद्रित होगी।
लॉजिकल ऑर (||) ऑपरेटर: यह दो बूलीय एक्सप्रेशन्स के लिए उपयोग किया जाता है और यदि दोनों से कम से कम एक सच होता है तो एक सच मान लौटाता है। अन्यथा, अगली शर्त जांची जाती है।
उदाहरण:
int a = 10, b = 5;
if (a < b || b > 0)
printf("At least one condition is true");
यहां, दोनों शर्तों में से कम से कम एक शर्त सच है, इसलिए "At least one condition is true" लाइन मुद्रित होगी।
Bitwise Operators:
बिटवाइज एंड (&) ऑपरेटर: यह बिटवाइज लॉजिकल एंड ऑपरेटरहै जो दो ऑपरेंड्स के हर बिट के बीच एक बिटवाइज लॉजिकल एंड ऑपरेशन करता है। यदि दोनों बिट सत्य हैं, तो नतीजा भी सत्य होगा।
उदाहरण:
unsigned int a = 60; // 0011 1100
unsigned int b = 13; // 0000 1101
unsigned int c = 0;
c = a & b; // 0000 1100
printf("Result: %d\n", c);
यहां, एक्सप्रेशन a & b बिटवाइज लॉजिकल एंड ऑपरेशन करता है। जैसा कि 60 का बाइनरी रूप है 0011 1100 और 13 का बाइनरी रूप है 0000 1101, इसलिए a & b का नतीजा 0000 1100 होगा जो दशमलव संख्या 12 के बराबर होता है।
बिटवाइज ऑर (|) ऑपरेटर: यह बिटवाइज लॉजिकल ऑर ऑपरेटर है जो दो ऑपरेंड्स के हर बिट के बीच एक बिटवाइज लॉजिकल ऑर ऑपरेशन करता है। यदि दोनों बिटों में से कम से कम एक सत्य होता है, तो नतीजा सत्य होता है।
उदाहरण:
unsigned int a = 60; // 0011 1100
unsigned int b = 13; // 0000 1101
unsigned int c = 0;
c = a | b; // 0011 1101
printf("Result: %d\n", c);
यहां, एक्सप्रेशन a | b बिटवाइज लॉजिकल ऑर ऑपरेशन करता है। जैसा कि 60 का बाइनरी रूप है 0011 1100 और 13 का बाइनरी रूरूप है 0000 1101, इसलिए a | b का नतीजा 0011 1101 होगा जो दशमलव संख्या 61 के बराबर होता है।
बिटवाइज एक्सऑर (^) ऑपरेटर: यह बिटवाइज लॉजिकल एक्सऑर ऑपरेटर है जो दो ऑपरेंड्स के हर बिट के बीच एक बिटवाइज लॉजिकल एक्सऑर ऑपरेशन करता है। यदि दोनों बिटों में से केवल एक सत्य होता है, तो नतीजा सत्य होता है।
उदाहरण:
unsigned int a = 60; // 0011 1100
unsigned int b = 13; // 0000 1101
unsigned int c = 0;
c = a ^ b; // 0011 0001
printf("Result: %d\n", c);
यहां, एक्सप्रेशन a ^ b बिटवाइज लॉजिकल एक्सऑर ऑपरेशन करता है। जैसा कि 60 का बाइनरी रूप है 0011 1100 और 13 का बाइनरी रूप है 0000 1101, इसलिए a ^ b का नतीजा 0011 0001 होगा जो दशमलव संख्या 49 के बराबर होता है।
ये थे कुछ मुख्य बिटवाइज ऑपरेटर्स जो सी भाषा में होते हैं। इनके अलावा भी कई अन्य बिटवाइज ऑपरेटर्स होते हैं जैसे बिटवाइज शिफ्ट ऑपरेटर्स (<<, >>) जो एक बाइनरी संख्या के बिटों को बाएं या दाएं खिसकाते हैं।
C भाषा में ऑपरेटरों की प्राथमिकता Operators Precedence
C भाषा में Operators Precedence (ऑपरेटरों की प्राथमिकता) निम्नलिखित तरीके से है:
| श्रेणी | ऑपरेटर | प्राथमिकता |
|---|---|---|
| 1 | () [] -> . | हाइ |
| 2 | ++ -- (postfix) | |
| 3 | ++ -- (prefix) + - ! ~ (type) * & sizeof | |
| 4 | * / % | |
| 5 | + - | |
| 6 | << >> | |
| 7 | < <= > >= | |
| 8 | == != | |
| 9 | & | |
| 10 | ^ | |
| 11 | | | |
| 12 | && | |
| 13 | || | |
| 14 | ? | |
| 15 | = += -= *= /= %= <<= >>= &= ^= |= | |
| 16 | , | लो |
ऑपरेटरों की प्राथमिकता टेबल में यह बताती है कि किस ऑपरेटर की प्राथमिकता अधिक होती है और कौन सा ऑपरेटर किससे पहले होगा। यह टेबल एक अच्छा संदर्भ होता है जब आप बहुत से ऑपरेटर का उपयोग करते होंगे और आपको समझ नहीं आ रहा होगा कि उन्हें किस अनुसार एक साथ लगाना है।
Operators Precedence ऑपरेटरों की प्राथमिकता का उदाहरण
1. () [] -> .
यह ऑपरेटर श्रेणी सबसे ज्यादा precedence रखती है। यह किसी भी व्यक्ति या ऑब्जेक्ट को उसकी विशेषताओं या फ़ंक्शन के लिए संदर्भित करने के लिए प्रयोग किया जाता है। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
struct Person {
char name[50];
int age;
};
int main() {
struct Person p1 = {"John", 30};
printf("%s\n", p1.name); // uses the dot operator to access the name member
printf("%d\n", p1.age); // uses the dot operator to access the age member
return 0;
}
2. ++ -- (postfix)
ये ऑपरेटर उच्च प्राथमिकता वाली श्रेणी में आते हैं। ये ऑपरेटर इंक्रीमेंट या डिक्रीमेंट करते हैं, जो कि एक वेरिएबल को इंक्रीमेंट या डिक्रीमेंट करने के लिए प्रयोग किया जाता है। पोस्टफिक्स ++ या -- उस वेरिएबल को इंक्रीमेंट या डिक्रीमेंट करते हैं, जो ऑपरेटर के बाद होता है। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 5;
int y = x++; // y = 5, x = 6
int z = y--; // z = 5, y = 4
3. ++ -- (prefix), + - ! ~ (type) * & sizeof
ये ऑपरेटर एक निम्न स ्त्रोत से उच्च प्राथमिकता वाली श्रेणी में आते हैं। ये ऑपरेटर यह निर्दिष्ट करते हैं कि किस तरह के ऑपरेशन को संपादित किया जाएगा। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 5;
int y = ++x; // y = 6, x = 6
int z = -x; // z = -6
int a = !x; // a = 0 (false)
int b = ~x; // b = -7
int c = sizeof(x); // c = 4 (size of integer)
4. * / %
ये ऑपरेटर मानों को गुणा, भाग या भागफल के लिए प्रयोग किए जाते हैं। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10, y = 5;
int a = x * y; // a = 50
int b = x / y; // b = 2
int c = x % y; // c = 0
5. + -
ये ऑपरेटर नंबर को जोड़ने या घटाने के लिए प्रयोग किए जाते हैं। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10, y = 5;
int a = x + y; // a = 15
int b = x - y; // b = 5
6. << >>
ये ऑपरेटर बाइट को बाईं या दाईं ओर स्थानांतरित करते हैं। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10; // 00001010 in binary
int a = x << 2; // 00101000, equivalent to 40
int b = x >> 2; // 00000010, equivalent to 2
7. < <= > >=
ये ऑपरेटर दो संख्याओं की तुलना करते हैं और सत्य या असत्य की जांच करते हैं। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10, y = 5;
int a = x < y; // a = 0 (false)
int b = x <= y; // b = 0 (false)
int c = x > y; // c = 1 (true)
int d = x >= y; // d = 1 (true)
8. == !=
ये ऑपरेटर दो संख्याओं की बराबरी या असमानता की जांच करते हैं। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:;
int a = x == y; // a = 0 (false)
int b = x != y; // b = 1 (true)
9. &
ये बाइनरी एंड ऑपरेटर होता है, जो बाइनरी में दो संख्याओं के बीच एक बाइट-बाइट लॉजिकल एंड ऑपरेशन करता है। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10; // 00001010 in binary
int y = 7; // 00000111 in binary
int a = x & y; // 00000010, equivalent to 2
10. ^
ये बाइनरी एक्सओर ऑपरेटर होता है, जो बाइनरी में दो संख्याओं के बीच बाइट-बाइट लॉजिकल एक्सओर ऑपरेशन करता है। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10; // 00001010 in binary
int y = 7; // 00000111 in binary
int a = x ^ y // 00001101, equivalent to 13
**11. |**
ये बाइनरी ऑर ऑपरेटर होता है, जो बाइनरी में दो संख्याओं के बीच बाइट-बाइट लॉजिकल ऑर ऑपरेशन करता है। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10; // 00001010 in binary
int y = 7; // 00000111 in binary
int a = x | y; // 00001111, equivalent to 15
**12. &&**
ये लॉजिकल एंड ऑपरेटर होता है, जो दो बूलियन वार्ताओं के बीच एक लॉजिकल एंड ऑपरेशन करता है। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10, y = 5;
int a = (x > y) && (y > 0); // a = 1 (true)
int b = (x < y) && (y > 0); // b = 0 (false)
**13. ||**
ये लॉजिकल ऑर ऑपरेटर होता है, जो दो बूलियन वार्ताओं के बीच एक लॉजिकल ऑर ऑपरेशन करता है। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10, y = 5;
int a = (x > y) || (y < 0); // a = 1 (true)
int b = (x < y) || (y < 0); // b = 0 (false)
14. ?:
ये टर्नरी ऑपरेटर होता है जो एक शर्त के आधार पर दो अलग-अलग वाल्यूज़ को चुनता है। इसको एक conditional operator भी कहते हैं। इसका उपयोग निम्नलिखित रूप से किया जाता है:
int x = 10, y = 5;
int a = (x > y) ? x : y; // a = 10
int b = (x < y) ? x : y; // b = 5
15. sizeof
ये एक यूनरी ऑपरेटर होता है जो वेरिएबल या डेटा टाइप का साइज़ रिटर्न करता है। इसका उपयोग निम्नलिखित रूप से किया जाता है:
int x = 10;
float y = 10.0;
char z = 'a';
printf("Size of x: %d\n", sizeof(x)); // Size of x: 4 bytes
printf("Size of y: %d\n", sizeof(y)); // Size of y: 4 bytes
printf("Size of z: %d\n", sizeof(z)); // Size of z: 1 byte
16. &
ये एक यूनरी ऑपरेटर होता है जो एक वेरिएबल के एड्रेस को रिटर्न करता है। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10;
printf("Address of x: %p", &x); // Address of x: 0x7ffeefbff54c
**17. * **
ये एक यूनरी ऑपरेटर होता है जो एक पॉइंटर के द्वारा डीरेक्ट औरिजन के वैल्यू को रिटर्न करता है। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 10;
int *ptr = &x;
printf("Value of x: %d\n", *ptr); // Value c भाषा में उपलब्ध होते हैं और ये ऑपरेटर प्राथमिकता के आधार पर काम करते हैं।
18. &
ये बाइनरी एम्पर्सैंड (&) एक बाइट-वाइज (byte-wise) एंड (AND) ऑपरेशन करता है। इसका उपयोग निम्नलिखित रूप से किया जाता है:
int x = 5; // Binary equivalent of 5 is 0101
int y = 3; // Binary equivalent of 3 is 0011
int z = x & y; // Binary equivalent of z is 0001, which is 1 in decimal
printf("z = %d", z); // z = 1
19. |
ये बाइनरी पाइप (|) एक बाइट-वाइज (byte-wise) ओर (OR) ऑपरेशन करता है। इसका उपयोग निम्नलिखित रूप से किया जाता है:
int x = 5; // Binary equivalent of 5 is 0101
int y = 3; // Binary equivalent of 3 is 0011
int z = x | y; // Binary equivalent of z is 0111, which is 7 in decimal
printf("z = %d", z); // z = 7
20. ^
ये बाइनरी करेट (^) एक बाइट-वाइज (byte-wise) एक्सऑर (XOR) ऑपरेशन करता है। इसका उपयोग निम्नलिखित रूप से किया जाता है:
int x = 5; // Binary equivalent of 5 is 0101
int y = 3; // Binary equivalent of 3 is 0011
int z = x ^ y; // Binary equivalent of z is 0110, which is 6 in decimal
printf("z = %d", z); // z = 6
21. ~
ये यूनरी टिल्डा (~) एक वाइज-वाइज (bit-wise) नॉट (NOT) ऑपरेशन करता है जो दिए गए वैल्यू के बाइट्स को इनवर्ट करता है। निम्नलिखित उदाहरण इसे समझाने में मदद करेंगे:
int x = 5; // Binary equivalent of 5 is
22. <<
ये बाइनरी शिफ्ट ऑपरेटर (<<) दिए गए बाइट्स को बाईं तरफ (left) निर्दिष्ट संख्या के बिटों से बढ़ाता है। इसका उपयोग निम्नलिखित रूप से किया जाता है:
int x = 5; // Binary equivalent of 5 is 0101
int z = x << 2; // Binary equivalent of z is 010100, which is 20 in decimal
printf("z = %d", z); // z = 20
23. >>
ये बाइनरी शिफ्ट ऑपरेटर (>>) दिए गए बाइट्स को दाईं तरफ (right) निर्दिष्ट संख्या के बिटों से घटाता है। इसका उपयोग निम्नलिखित रूप से किया जाता है:
int x = 20; // Binary equivalent of 20 is 10100
int z = x >> 2; // Binary equivalent of z is 00101, which is 5 in decimal
printf("z = %d", z); // z = 5
दो या अधिक ऑपरेटर्स को एक साथ उपयोग
C भाषा के ऑपरेटर्स को एक साथ उपयोग करके भी इन्हें अधिक उपयोगी बना सकते हैं। इसके यहां कुछ उदाहरण हैं:
1. Assignment and Arithmetic Operators:
आप असाइनमेंट ऑपरेटर को अंकों के साथ उपयोग करके संख्याओं को निर्दिष्ट ताकत तक बढ़ा सकते हैं।
int x = 5, y = 10;
x += y; // equivalent to x = x + y;
printf("x = %d", x); // output: x = 15
2. Logical and Relational Operators:
आप एकाधिक तर्कों को एक साथ लॉजिकल ऑपरेटर का उपयोग करके संयुक्त अभिव्यक्तियों को समझ सकते हैं।
int x = 5, y = 10;
if (x > 0 && y > 0) {
printf("Both x and y are positive");
}
यहां लॉजिकल ऑपरेटर "&&" का उपयोग किया गया है जो दो संख्याओं की स्थितियों को एक साथ जांचता है।
3. Bitwise Operators:
बिटवाइज ऑपरेटर का उपयोग करके, आप दो बाइनरी संख्याओं के बिटों के साथ काम कर सकते हैं।
unsigned int x = 60; // Binary equivalent of 60 is 00111100
unsigned int y = 13; // Binary equivalent of 13 is 00001101
unsigned int z = x & y; // Binary equivalent of z is 00001100, which is 12 in decimal
printf("z = %d", z); // output: z = 12
यहां आप बिटवाइज ऑपरेटर "&" का उपयोग करके दो बाइनरी संख्याओं के बिट बाईं तरफ संयुक्त लोगिकल "एंड" क
4. Conditional Operator:
शर्तग्रस्त ऑपरेटर का उपयोग करके, आप एक संख्या के आधार पर दो अलग-अलग मानों को निर्दिष्ट कर सकते हैं।
int x = 5, y = 10, z;
z = (x > y) ? x : y;
printf("z = %d", z); // output: z = 10
यहां "शर्तग्रस्त" ऑपरेटर "?" का उपयोग किया गया है। यह शर्त के अनुसार एक मान चुनता है जो कि सत्य होता है।
5. Bitwise and Assignment Operators:
बिटवाइज और असाइनमेंट ऑपरेटर का उपयोग करके, आप दो बाइनरी संख्याओं के बिटों के साथ काम कर सकते हैं और उन्हें असाइन कर सकते हैं।
unsigned int x = 60; // Binary equivalent of 60 is 00111100
unsigned int y = 13; // Binary equivalent of 13 is 00001101
x |= y; // Binary equivalent of x is now 00111101, which is 61 in decimal
printf("x = %d", x); // output: x = 61
यहां आप बिटवाइज और असाइनमेंट ऑपरेटर "|=" का उपयोग करते हुए दो बाइनरी संख्याओं को संयुक्त करते हुए उसे x के साथ असाइन करते हैं।
इस तरह से, ऑपरेटर को कम्बाइन करने के द्वारा आप अपने कोड को अधिक सरल और उपयोगी बना सकते हैं।
इस उदाहरण में, सभी ऑपरेटरों का उपयोग करके दिखाया है जिसे इनमे अंतर पता चल सके:
#include <stdio.h>
int main() {
int a = 10, b = 5, c;
c = a + b; // Addition Operator
printf("c = %d\n", c); // Output: c = 15
c = a - b; // Subtraction Operator
printf("c = %d\n", c); // Output: c = 5
c = a * b; // Multiplication Operator
printf("c = %d\n", c); // Output: c = 50
c = a / b; // Division Operator
printf("c = %d\n", c); // Output: c = 2
c = a % b; // Modulus Operator
printf("c = %d\n", c); // Output: c = 0
a++; // Increment Operator
printf("a = %d\n", a); // Output: a = 11
b--; // Decrement Operator
printf("b = %d\n", b); // Output: b = 4
c = a == b; // Equality Operator
printf("c = %d\n", c); // Output: c = 0
c = a != b; // Not Equal Operator
printf("c = %d\n", c); // Output: c = 1
c = a > b; // Greater Than Operator
printf("c = %d\n", c); // Output: c = 1
c = a < b; // Less Than Operator
printf("c = %d\n", c); // Output: c = 0
c = a >= b; // Greater Than or Equal To Operator
printf("c = %d\n", c); // Output: c = 1
c = a <= b; // Less Than or Equal To Operator
printf("c = %d\n", c); // Output: c = 0
c = (a > b) ? a : b; // Conditional Operator
printf("c = %d\n", c); // Output: c = 11
a &= b; // Bitwise AND Assignment Operator
printf("a = %d\n", a); // Output: a = 0
a |= b; // Bitwise OR Assignment Operator
printf("a = %d\n", a); // Output: a = 4
a ^= b; // Bitwise XOR Assignment Operator
printf("a = %d\n", a); // Output: a = 1
a >>= 2; // Bitwise Right Shift Assignment Operator
printf("a = %d\n", a); // Output: a = 0
a <<= 2; // Bitwise Left Shift Assignment Operator
printf("a = %d\n", a); // Output: a = 4
return 0;
}
इस उदाहरण में अरिथ्मेटिक ऑपरेटर्स (+, -, *, /, %) और इनके साथ संबंधित समीकरण उपयोग किए हैं। इसके अलावा, निर्णय ऑपरेटर (==, !=, >, <, >=, <=) का उपयोग भी किया है। इसके अतिरिक्त, वृद्धि और क्रमशः घटाने वाले ऑपरेटर (++, --) का उपयोग भी किया है। अंतिम तीन ऑपरेटर (बिटवाइज एंड, बिटवाइज ऑर, बिटवाइज एक्स-ऑर) का उपयोग बिटवाइज ऑपरेशन करने के लिए किया गया है। इन ऑपरेटरों को एक साथ उपयोग करके, हम संख्याओं की विस्तृत श्रृंखला को जोड़ने, घटाने, गुणा करने, और भाग करने के अलावा, निर्णय कर सकते हैं कि एक नंबर दूसरे संख्या से बड़ा है या नहीं, उन्हें तुलना कर सकते हैं या उन्हें बिटवाइज ऑपरेशन कर सकते हैं।
