सी ++ में ऑपरेटर ओवरलोडिंग

आपका दिन शुभ हो!

इस लेख को लिखने की इच्छा पोस्ट ओवरलोडिंग सी ++ ऑपरेटरों को पढ़ने के बाद दिखाई दी, क्योंकि कई महत्वपूर्ण विषय इसमें शामिल नहीं थे।

याद रखने वाली सबसे महत्वपूर्ण बात ऑपरेटर ओवरलोडिंग है, यह फ़ंक्शन को कॉल करने का एक अधिक सुविधाजनक तरीका है, इसलिए आपको ऑपरेटर ओवरलोडिंग में शामिल नहीं होना चाहिए। इसका उपयोग केवल तब करें जब यह लेखन कोड को आसान बना दे। लेकिन, इतना नहीं कि इससे पढ़ना मुश्किल हो गया। आखिरकार, जैसा कि आप जानते हैं, कोड को लिखा जाने की तुलना में अधिक बार पढ़ा जाता है। और यह मत भूलो कि आपको कभी भी निर्मित प्रकारों के साथ मिलकर ऑपरेटरों को ओवरलोड करने की अनुमति नहीं दी जाएगी, ओवरलोडिंग की संभावना केवल कस्टम प्रकार / वर्गों के लिए है।

अधिभार सिंटैक्स

ऑपरेटर ओवरलोड सिंटैक्स ऑपरेटर @ नामक एक फ़ंक्शन को परिभाषित करने के समान है, जहां @ ऑपरेटर की पहचानकर्ता है (जैसे +, -, <<, >>)। सबसे सरल उदाहरण पर विचार करें:

class Integer { private: int value; public: Integer(int i): value(i) {} const Integer operator+(const Integer& rv) const { return (value + rv.value); } }; 

इस मामले में, ऑपरेटर को वर्ग के सदस्य के रूप में तैयार किया जाता है, तर्क ऑपरेटर के दाईं ओर स्थित मूल्य निर्धारित करता है। सामान्य तौर पर, ऑपरेटरों को ओवरलोड करने के दो मुख्य तरीके हैं: वैश्विक कार्य जो कक्षा के लिए अनुकूल हैं, या स्वयं कक्षा के इनलाइन फ़ंक्शन। कौन सी विधि, किस ऑपरेटर के लिए बेहतर है, हम विषय के अंत में विचार करेंगे।

ज्यादातर मामलों में, ऑपरेटर (सशर्त वाले को छोड़कर) एक ऑब्जेक्ट, या उस प्रकार के संदर्भ को संदर्भित करते हैं, जिसके तर्क संबंधित हैं (यदि प्रकार भिन्न हैं, तो आप तय करते हैं कि ऑपरेटर के मूल्यांकन के परिणाम की व्याख्या कैसे करें)।

ओवररेटिंग यूनरी ऑपरेटर्स

आइए उपरोक्त परिभाषित किए गए इंटेगर वर्ग के लिए अपर संचालकों की ओवरलोडिंग के उदाहरण देखें। उसी समय, हम उन्हें अनुकूल कार्यों के रूप में परिभाषित करते हैं और वेतन वृद्धि और वृद्धि ऑपरेटरों पर विचार करते हैं:

 class Integer { private: int value; public: Integer(int i): value(i) {} // + friend const Integer& operator+(const Integer& i); // - friend const Integer operator-(const Integer& i); //  friend const Integer& operator++(Integer& i); //  friend const Integer operator++(Integer& i, int); //  friend const Integer& operator--(Integer& i); //  friend const Integer operator--(Integer& i, int); }; //    . const Integer& operator+(const Integer& i) { return i.value; } const Integer operator-(const Integer& i) { return Integer(-i.value); } //      const Integer& operator++(Integer& i) { i.value++; return i; } //      const Integer operator++(Integer& i, int) { Integer oldValue(i.value); i.value++; return oldValue; } //      const Integer& operator--(Integer& i) { i.value--; return i; } //      const Integer operator--(Integer& i, int) { Integer oldValue(i.value); i.value--; return oldValue; } 

अब आप जानते हैं कि संकलक कैसे घटाव और वृद्धि के उपसर्ग और उपसर्ग संस्करणों के बीच अंतर करता है। मामले में जब वह अभिव्यक्ति + i देखता है, तो ऑपरेटर ++ (ए) फ़ंक्शन को कहा जाता है। यदि वह i ++ देखता है, तो ऑपरेटर ++ (a, int) कहा जाता है। यही है, अतिभारित ऑपरेटर ++ फ़ंक्शन को कहा जाता है, और यह इसके लिए है कि पोस्टफ़िक्स संस्करण में डमी इंट पैरामीटर का उपयोग किया जाता है।

बाइनरी ऑपरेटर्स

बाइनरी ऑपरेटरों को ओवरलोड करने के लिए सिंटैक्स पर विचार करें। एक कथन, जो एक एल-मान लौटाता है, एक सशर्त विवरण और एक कथन जो एक नया मूल्य बनाता है, को अधिभारित करता है (विश्व स्तर पर उन्हें परिभाषित करें):

 class Integer { private: int value; public: Integer(int i): value(i) {} friend const Integer operator+(const Integer& left, const Integer& right); friend Integer& operator+=(Integer& left, const Integer& right); friend bool operator==(const Integer& left, const Integer& right); }; const Integer operator+(const Integer& left, const Integer& right) { return Integer(left.value + right.value); } Integer& operator+=(Integer& left, const Integer& right) { left.value += right.value; return left; } bool operator==(const Integer& left, const Integer& right) { return left.value == right.value; } 

इन सभी उदाहरणों में, ऑपरेटरों को एक प्रकार के लिए अतिभारित किया जाता है, हालांकि, यह आवश्यक नहीं है। उदाहरण के लिए, आप अपनी समानता में परिभाषित हमारे प्रकार के पूर्णांक और फ़्लोट को जोड़ सकते हैं।

तर्क और वापसी मूल्य

जैसा कि आप देख सकते हैं, उदाहरण कार्यों के लिए तर्कों को पारित करने और ऑपरेटर मूल्यों को वापस करने के लिए विभिन्न तरीकों का उपयोग करते हैं।

• यदि तर्क ऑपरेटर द्वारा बदला नहीं जाता है, उदाहरण के लिए, एक यूनीरी प्लस, तो इसे स्थिरांक के संदर्भ के रूप में पारित किया जाना चाहिए। सामान्य तौर पर, यह लगभग सभी अंकगणितीय ऑपरेटरों (जोड़, घटाव, गुणा ...) के लिए सही है।
• वापसी मूल्य का प्रकार कथन की प्रकृति पर निर्भर करता है। यदि ऑपरेटर को एक नया मान वापस करना होगा, तो एक नई वस्तु बनाना आवश्यक है (जैसा कि एक बाइनरी प्लस के मामले में)। यदि आप ऑब्जेक्ट को एल-मान के रूप में बदलने पर रोक लगाना चाहते हैं, तो आपको इसे लगातार वापस करने की आवश्यकता है।
• असाइनमेंट ऑपरेटरों के लिए, आपको बदली गई वस्तु का लिंक वापस करना होगा। इसके अलावा, यदि आप फॉर्म (x = y) .f () के निर्माण में असाइनमेंट ऑपरेटर का उपयोग करना चाहते हैं, जहां चर x के लिए f () फ़ंक्शन को कॉल किया जाता है, तो इसे y को असाइन करने के बाद, निरंतर का संदर्भ नहीं लौटाते हैं, बस संदर्भ वापस करें।
• बूलियन ऑपरेटरों को सबसे खराब इंट, और सबसे अच्छे बूल पर लौटना चाहिए।

वापसी मान अनुकूलन

नई ऑब्जेक्ट बनाते समय और उन्हें किसी फ़ंक्शन से वापस करते समय, बाइनरी प्लस ऑपरेटर के उपरोक्त उदाहरण के लिए रिकॉर्ड का उपयोग करें।

 return Integer(left.value + right.value); 

ईमानदारी से, मुझे नहीं पता कि C ++ 11 के लिए कौन सी स्थिति प्रासंगिक है, नीचे दिए गए सभी तर्क C ++ 98 के लिए मान्य हैं।
पहली नज़र में, यह एक अस्थायी ऑब्जेक्ट बनाने के लिए सिंटैक्स के समान है, जैसे कि कोड और उसके बीच कोई अंतर नहीं है:

 Integer temp(left.value + right.value); return temp; 

लेकिन वास्तव में, इस मामले में, कंस्ट्रक्टर को पहली पंक्ति पर बुलाया जाएगा, फिर कॉपी कंस्ट्रक्टर को कॉल किया जाएगा, जो ऑब्जेक्ट को कॉपी करेगा, और फिर, जब स्टैक अनबाउंड है, तो विध्वंसक कहा जाएगा। पहले रिकॉर्ड का उपयोग करते समय, संकलक शुरू में मेमोरी में एक ऑब्जेक्ट बनाता है जिसमें इसे कॉपी करना है, इस प्रकार कॉल को कॉपी कंस्ट्रक्टर और डिस्ट्रक्टर में सहेजना है।

विशेष संचालक

C ++ में ऐसे ऑपरेटर होते हैं जिनके पास विशिष्ट सिंटैक्स और ओवरलोडिंग विधियां होती हैं। उदाहरण के लिए, इंडेक्स ऑपरेटर []। इसे हमेशा कक्षा के एक सदस्य के रूप में परिभाषित किया जाता है, और चूंकि अनुक्रमित ऑब्जेक्ट का व्यवहार एक सरणी के रूप में निहित होता है, इसलिए इसे एक संदर्भ वापस करना चाहिए।

कोमा संचालक

"विशेष" ऑपरेटरों में अल्पविराम ऑपरेटर भी शामिल हैं। इसे बगल में अल्पविराम वाली वस्तुओं के लिए कहा जाता है (लेकिन इसे फ़ंक्शन तर्क सूचियों में नहीं कहा जाता है)। इस ऑपरेटर का उपयोग करने के एक सार्थक उदाहरण के साथ आने के लिए इतना आसान नहीं है। ओवरलोड पर पिछले लेख की टिप्पणियों में हेबरूसर एक्सिसपॉड ने एक बात की ।

सूचक परिचालक ऑपरेटर

इन ऑपरेटरों को अधिभार देना स्मार्ट पॉइंटर कक्षाओं के लिए उचित हो सकता है। यह ऑपरेटर आवश्यक रूप से वर्ग के एक फ़ंक्शन के रूप में परिभाषित किया गया है, और इस पर कुछ प्रतिबंध लगाए गए हैं: इसे या तो एक ऑब्जेक्ट (या लिंक) या एक पॉइंटर वापस करना होगा जो आपको ऑब्जेक्ट तक पहुंचने की अनुमति देता है।

असाइनमेंट ऑपरेटर

असाइनमेंट ऑपरेटर को आवश्यक रूप से वर्ग के एक फ़ंक्शन के रूप में परिभाषित किया गया है, क्योंकि यह "=" के बाईं ओर ऑब्जेक्ट के साथ अटूट रूप से जुड़ा हुआ है। असाइनमेंट ऑपरेटर को विश्व स्तर पर परिभाषित करने से "=" ऑपरेटर के मानक व्यवहार को ओवरराइड करना संभव होगा। एक उदाहरण:

 class Integer { private: int value; public: Integer(int i): value(i) {} Integer& operator=(const Integer& right) { //   if (this == &right) { return *this; } value = right.value; return *this; } }; 

जैसा कि आप देख सकते हैं, फ़ंक्शन की शुरुआत में, स्व-असाइनमेंट के लिए एक चेक बनाया गया है। सामान्य तौर पर, इस मामले में, स्व-असाइनमेंट हानिरहित है, लेकिन स्थिति हमेशा इतनी सरल नहीं होती है। उदाहरण के लिए, यदि ऑब्जेक्ट बड़ा है, तो आप अनावश्यक नकल पर, या पॉइंटर्स के साथ काम करते समय बहुत समय बिता सकते हैं।

नॉन-ओवरलोडिंग ऑपरेटर

C ++ में कुछ ऑपरेटर सिद्धांत रूप में अतिभारित नहीं हैं। जाहिर है, यह सुरक्षा कारणों से किया जाता है।

• कक्षा सदस्य का चयन करने वाला ऑपरेटर "" है।
• ऑपरेटर, कक्षा के एक सदस्य को एक संकेतक "" दे रहा है।
• C ++ में, कोई एक्सपेंटरशिप ऑपरेटर (जैसे कि फोरट्रान में) "**" नहीं है।
• अपने स्वयं के ऑपरेटरों को परिभाषित करना निषिद्ध है (प्राथमिकता के साथ समस्याएं हो सकती हैं)।
• आप ऑपरेटर प्राथमिकताएं नहीं बदल सकते

ऑपरेटर परिभाषा प्रपत्र के लिए दिशानिर्देश

जैसा कि हम पहले ही पता लगा चुके हैं, ऑपरेटरों के दो तरीके हैं - एक क्लास फंक्शन के रूप में और एक फ्रेंडली ग्लोबल फंक्शन के रूप में।
रोब मुर्रे ने अपनी पुस्तक C ++ रणनीतियाँ और रणनीति में, ऑपरेटर के रूप को चुनने के लिए निम्नलिखित दिशानिर्देशों की रूपरेखा प्रस्तुत की:

ऑपरेटर	अनुशंसित प्रपत्र
सभी एकरी संचालक	कक्षा सदस्य
= () [] -> -> *	आवश्यक वर्ग सदस्य
+ = - = / = * = ^ = = = = =% = >> = << =	कक्षा सदस्य
बाकी बाइनरी ऑपरेटर्स	वर्ग का सदस्य नहीं

ऐसा क्यों? सबसे पहले, कुछ ऑपरेटरों को शुरू में सीमित किया गया था। सामान्य तौर पर, यदि किसी ऑपरेटर को परिभाषित करने के तरीके में कोई शब्दार्थिक अंतर नहीं है, तो कनेक्शन को महत्व देने के लिए इसे क्लास फ़ंक्शन के रूप में डिज़ाइन करना बेहतर है, साथ ही फ़ंक्शन इनलाइन होगा। इसके अलावा, कभी-कभी किसी अन्य वर्ग की वस्तु के रूप में बाएं हाथ के ऑपरेंड का प्रतिनिधित्व करने की आवश्यकता हो सकती है। संभवतः सबसे हड़ताली उदाहरण इनपुट / आउटपुट धाराओं के लिए << और >> का पुन: निर्धारण है।

साहित्य

ब्रूस एकेल - फिलोसोफी ऑफ सी ++। मानक C ++ का परिचय ।