C++ कई यूनरी ऑपरेटरों का समर्थन करता है, जिनमें से प्रत्येक वेरिएबल में हेरफेर करने में एक अद्वितीय उद्देश्य प्रदान करता है। आइए वेतन वृद्धि और वेतन वृद्धि ऑपरेटरों से शुरू करें जो आमतौर पर लूप और विभिन्न एल्गोरिदम में उपयोग किए जाते हैं।
उदाहरण 1: वेतन वृद्धि (++) और वेतन वृद्धि (-) संचालक
वृद्धि (++) और वेतन वृद्धि (-) यूनरी ऑपरेटर C++ में एक चर के मान को क्रमशः 1 से बढ़ाकर या घटाकर संशोधित करने के लिए मौलिक उपकरण हैं। इंक्रीमेंट ऑपरेटर (++) वेरिएबल के मान में 1 जोड़ता है, जबकि डिक्रीमेंट ऑपरेटर (-) 1 घटाता है। इन ऑपरेटरों को पूर्णांक, फ़्लोटिंग-पॉइंट और पॉइंटर वेरिएबल पर लागू किया जा सकता है, जो उनके उपयोग में लचीलापन प्रदान करता है।
आइए एक व्यावहारिक उदाहरण के माध्यम से इन ऑपरेटरों का पता लगाएं:
#शामिल करें
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( )
{
int यहाँ विरोध करना = 0 ;
// इंक्रीमेंट ऑपरेटर
अदालत << 'आरंभिक मूल्य: ' << विरोध करना << अंतः ;
विरोध करना ++ ;
अदालत << 'वृद्धि के बाद मूल्य:' << विरोध करना << अंतः ;
// डिक्रीमेंट ऑपरेटर
विरोध करना -- ;
अदालत << 'घटने के बाद मूल्य:' << विरोध करना << अंतः ;
वापस करना 0 ;
}
इस सरल C++ प्रोग्राम में '#include
इस ऑपरेशन के बाद, 'काउंटर' का अद्यतन मान दूसरे 'काउट' स्टेटमेंट का उपयोग करके प्रदर्शित किया जाता है। इसके बाद, हम 'काउंटर' के मान को 1 से कम करने के लिए डिक्रीमेंट ऑपरेटर (काउंटर-) का उपयोग करते हैं। परिणाम बाद में कंसोल पर प्रदर्शित होता है। अंततः, प्रोग्राम 'रिटर्न 0;' के साथ समाप्त होता है। कथन जो सफल निष्पादन का संकेत देता है।
आउटपुट छवि प्रारंभिक मान, वृद्धि के बाद का मान और घटा हुआ मान दिखाती है।
उदाहरण 2: सकारात्मक (+) और नकारात्मक (-) संकारक
जबकि सकारात्मक यूनरी ऑपरेटर का उपयोग शायद ही कभी किया जाता है, नकारात्मक ऑपरेटर एक चर के संकेत को बदलने के लिए मौलिक है।
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
int यहाँ सकारात्मक मूल्य = 10 ;
int यहाँ नकारात्मक मूल्य = - सकारात्मक मूल्य ;
अदालत << 'सकारात्मक मूल्य:' << सकारात्मक मूल्य << अंतः ;
अदालत << 'नकारात्मक मान:' << नकारात्मक मूल्य << अंतः ;
वापस करना 0 ;
}
हम इस उदाहरण कोड के लिए दो पूर्णांक चर प्रारंभ करते हैं जो 'सकारात्मक वैल्यू' और 'नकारात्मक वैल्यू' हैं। 'पॉजिटिववैल्यू' को 10 के मान के साथ निर्दिष्ट किया गया है। इसके बाद, हम 'नेगेटिववैल्यू' की घोषणा करते हैं और इसे यूनरी माइनस ऑपरेटर का उपयोग करके 'पॉजिटिववैल्यू' के निषेध के साथ असाइन करते हैं। यह ऑपरेटर मूल मान के चिह्न को प्रभावी ढंग से बदल देता है। फिर हम कंसोल पर सकारात्मक और नकारात्मक दोनों आउटपुट प्रदर्शित करने के लिए 'काउट' कथन का उपयोग करते हैं। अंत में, प्रोग्राम 0 लौटाता है जो मुख्य फ़ंक्शन के सफल समापन को इंगित करता है।
निष्पादित होने पर, यह प्रोग्राम सकारात्मक और नकारात्मक मान आउटपुट करता है।
उदाहरण 3: तार्किक नहीं (!) ऑपरेटर
C++ में यूनरी ऑपरेटर, जिसे “!” प्रतीक, तार्किक NOT ऑपरेटर के रूप में जाना जाता है। इसे किसी दी गई अभिव्यक्ति के सत्य मान को उलटने के लिए डिज़ाइन किया गया है। यह एक एकल ऑपरेंड पर काम करता है जो आम तौर पर एक तार्किक अभिव्यक्ति या एक शर्त है। जब ऑपरेंड 'गलत' होता है तो तार्किक NOT ऑपरेशन 'सही' परिणाम देता है और जब ऑपरेंड 'सही' होता है तो 'गलत' परिणाम देता है।
यहां एक सरल उदाहरण दिया गया है जो तार्किक NOT ऑपरेटर के उपयोग को प्रदर्शित करता है:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
बूल क्या सच है = सत्य ;
बूल गलत है = असत्य ;
बूल परिणामसच्चा नहीं = ! क्या सच है ;
बूल परिणामगलतनहीं = ! गलत है ;
अदालत << 'असली कीमत: ' << क्या सच है << ', नहीं के बाद:' << परिणामसच्चा नहीं << अंतः ;
अदालत << 'असली कीमत: ' << गलत है << ', नहीं के बाद:' << परिणामगलतनहीं << अंतः ;
वापस करना 0 ;
}
इस उदाहरण में, हम दो बूलियन वैरिएबल, 'isTrue' और 'isFalse' घोषित करते हैं। फिर हम प्रत्येक वेरिएबल पर तार्किक NOT ऑपरेटर लागू करते हैं, परिणामों को क्रमशः 'resultNotTrue' और 'resultNotFalse' में संग्रहीत करते हैं। प्रोग्राम बाद में दोनों वेरिएबल्स के लिए मूल मान और तार्किक NOT ऑपरेशन के परिणाम प्रिंट करता है।
इस प्रोग्राम को निष्पादित करने पर, हम देखेंगे कि तार्किक NOT ऑपरेटर 'isTrue' (प्रारंभ में सत्य पर सेट) के सत्य मान को उलट देता है, जिससे यह गलत हो जाता है। इसी तरह, यह 'isFalse' (मूल रूप से गलत) के सत्य मान को उलट देता है, जिससे सत्य प्राप्त होता है।
आउटपुट स्पष्ट रूप से उन सत्य मूल्यों के व्युत्क्रम को दर्शाता है जो तार्किक NOT ऑपरेटर द्वारा प्राप्त किए जाते हैं।
उदाहरण 4: बिटवाइज़ नॉट (~) ऑपरेटर
C++ में बिटवाइज़ NOT ऑपरेटर (~) एक यूनरी ऑपरेटर है जो अपने ऑपरेंड के प्रत्येक बिट का बिटवाइज़ नेगेशन करता है। यह मौलिक डेटा प्रकारों, विशेष रूप से अभिन्न डेटा प्रकारों, जैसे पूर्णांक, के साथ कार्य करता है। परिणाम ऑपरेंड में प्रत्येक व्यक्तिगत बिट को उल्टा करके, 0s को 1s और 1s को 0s में परिवर्तित करके प्राप्त किया जाता है।
इसके उपयोग को स्पष्ट करने के लिए, निम्नलिखित कोड स्निपेट पर विचार करें:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
int यहाँ असली कीमत = 5 ;
int यहाँ परिणामबिटवाइज़नॉट = ~मूलमूल्य ;
अदालत << 'असली कीमत: ' << असली कीमत << ', बिटवाइज़ के बाद नहीं:' << परिणामबिटवाइज़नॉट << अंतः ;
वापस करना 0 ;
}
इस उदाहरण में, हम '5' के मान के साथ एक 'originalValue' पूर्णांक चर घोषित करते हैं। इसके बाद, हम इस वेरिएबल पर बिटवाइज़ NOT ऑपरेटर (~) का उपयोग करते हैं। इस वेरिएबल का परिणाम 'resultBitवाइजनॉट' में संग्रहीत है। प्रोग्राम 'काउट' स्टेटमेंट का उपयोग करके बिटवाइज़ नॉट ऑपरेशन के बाद मूल मान और परिणाम प्रिंट करता है।
जब हम इस प्रोग्राम को चलाते हैं, तो हम देखेंगे कि बिटवाइज़ नॉट ऑपरेटर 'ओरिजिनलवैल्यू' के बाइनरी प्रतिनिधित्व के प्रत्येक बिट को उलट देता है, जिसके परिणामस्वरूप एक नया मान प्राप्त होता है।
उदाहरण 5: पता और संकेत संचालक
ऑपरेटर का पता, जिसे '&' प्रतीक द्वारा दर्शाया जाता है, एक चर के मेमोरी स्थान को पुनः प्राप्त करने के उद्देश्य से कार्य करता है। यह वेरिएबल के लिए एक पॉइंटर लौटाता है जो इसके मूल्य तक अप्रत्यक्ष पहुंच को सक्षम बनाता है। इनडायरेक्शन या डीरेफ़रेंस ऑपरेटर (*) उस मान को प्राप्त करता है जो एक पॉइंटर द्वारा निर्दिष्ट मेमोरी स्थान पर संग्रहीत होता है। यह अप्रत्यक्ष रूप से एक पॉइंटर के माध्यम से वास्तविक डेटा के साथ काम करने का एक तरीका प्रदान करता है।
आइए इस अवधारणा को एक उदाहरण से समझें:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
int यहाँ कीमत = 99 ;
अदालत << 'असली कीमत: ' << कीमत << अंतः ;
int यहाँ * पीटीआर = & कीमत ;
अदालत << 'मेमोरी पता:' << पीटीआर << अंतः ;
int यहाँ पुनर्प्राप्त मूल्य = * पीटीआर ;
अदालत << 'पुनर्प्राप्त मूल्य:' << पुनर्प्राप्त मूल्य << अंतः ;
वापस करना 0 ;
}
यह कोड पता और अप्रत्यक्ष ऑपरेटरों के उपयोग का उदाहरण देता है। सबसे पहले, 'मान' नामक एक पूर्णांक चर को 99 के मान के साथ प्रारंभ किया जाता है। 'मान' का मूल मान फिर कंसोल पर आउटपुट किया जाता है। इसके बाद, एक 'पीटीआर' पॉइंटर वैरिएबल घोषित किया जाता है, और 'वैल्यू' के मेमोरी एड्रेस को 'पीटीआर' को निर्दिष्ट करने के लिए ऑपरेटर का पता (&) नियोजित किया जाता है। प्रोग्राम तब इस मेमोरी एड्रेस को आउटपुट करता है, जो 'एड्रेस' ऑपरेटर के मूल संचालन को प्रदर्शित करता है।
उसके बाद, एक नया पूर्णांक वैरिएबल जो 'retrievedValue' है, घोषित किया जाता है, और अप्रत्यक्ष ऑपरेटर (*) को 'ptr' द्वारा बताए गए मेमोरी पते पर संग्रहीत मान को पुनर्प्राप्त करने के लिए नियोजित किया जाता है। पुनर्प्राप्त मान को फिर कंसोल पर आउटपुट किया जाता है।
निष्कर्ष
यह आलेख C++ में यूनरी ऑपरेटरों की व्यापक खोज प्रदान करता है। हमने यूनरी ऑपरेटरों को अंकगणित, तार्किक, बिटवाइज़ और पते और संकेत से संबंधित विभिन्न प्रकारों में वर्गीकृत करके शुरू किया। इन ऑपरेटरों के उपयोगी अनुप्रयोग को प्रदर्शित करने के लिए वास्तविक दुनिया की स्थितियों का उदाहरण दिया गया। ये ऑपरेटर C++ प्रोग्रामिंग में महत्वपूर्ण भूमिका निभाते हैं जो डेवलपर्स को पॉइंटर्स के साथ कुशलता से काम करने और मेमोरी को प्रबंधित करने की अनुमति देता है।