आप '।' को अधिभार क्यों नहीं दे सकते सी ++ में ऑपरेटर?

Question

यह अधिभारित करने में सक्षम होने के लिए बहुत उपयोगी होगा। सी ++ में ऑपरेटर और किसी ऑब्जेक्ट का संदर्भ लौटाएं।

आप operator-> ओवरलोड कर सकते हैं और operator* नहीं बल्कि operator.

वहाँ इस के लिए एक तकनीकी कारण है?

Answer 1

this quote from Bjarne Stroustrup देखें:

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

class Y { 
public: 
    void f(); 
    // ... 
}; 

class X { // assume that you can overload . 
    Y* p; 
    Y& operator.() { return *p; } 
    void f(); 
    // ... 
}; 

void g(X& x) 
{ 
    x.f(); // X::f or Y::f or error? 
} 

इस समस्या को कई तरीकों से हल किया जा सकता है। मानकीकरण के समय, यह स्पष्ट नहीं था कि किस तरह से सबसे अच्छा होगा। अधिक विवरण के लिए, The Design and Evolution of C++ देखें।

Answer 2

Stroustrup has an answer for this question:

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

class Y { 
public: 
    void f(); 
    // ... 
}; 
class X { // assume that you can overload . 
    Y* p; 
    Y& operator.() { return *p; } 
    void f(); 
    // ... 
}; 
void g(X& x) 
{ 
    x.f(); // X::f or Y::f or error? 
} 

यह समस्या कई तरीकों से हल किया जा सकता। मानकीकरण के समय, यह स्पष्ट नहीं था कि सबसे अच्छा तरीका होगा। अधिक जानकारी के लिए, D&E देखें।

Answer 3

स्ट्रॉस्ट्रप ने कहा कि सी ++ एक एक्स्टेंसिबल होना चाहिए, लेकिन परिवर्तनीय भाषा नहीं होनी चाहिए।

डॉट (विशेषता पहुंच) ऑपरेटर को ओवरलोडिंग की अनुमति देने के लिए भाषा के मूल के बहुत करीब के रूप में देखा गया था।

The Design and Evolution of C++, पृष्ठ 242, सेक्शन 11.5.2 स्मार्ट संदर्भ देखें।

जब मैं ऑपरेटर -> की ओवरलोडिंग की अनुमति देने का फैसला किया, मैं स्वाभाविक रूप से माना जाता है कि क्या ऑपरेटर . इसी तरह अतिभारित किया जा सकता है।

समय में, मैं निम्नलिखित तर्क निर्णायक माना: अगर obj एक वर्ग वस्तु है तो obj.m उस वस्तु की क्लास के हर सदस्य m के लिए एक अर्थ नहीं है। हम बिल्ट-इन ऑपरेशंस को फिर से परिभाषित करके भाषा को व्यवहार्य बनाने की कोशिश नहीं करते हैं (हालांकि उस नियम का उल्लंघन = के लिए सख्त आवश्यकता से, और & के लिए उल्लंघन किया गया है)।

यदि हमें कक्षा X के लिए ओवरलोडिंग की अनुमति है, तो हम सामान्य माध्यम से X के सदस्यों तक पहुंचने में असमर्थ होंगे; हमें एक पॉइंटर और -> का उपयोग करना होगा, लेकिन -> और & को फिर से परिभाषित किया जा सकता है। मैं एक एक्स्टेंसिबल भाषा चाहता था, एक उत्परिवर्तनीय नहीं।

ये तर्क भारी हैं, लेकिन निर्णायक नहीं हैं। विशेष रूप से, 1 99 0 में जिम एडकॉक ने ऑपरेटर .बिल्कुल ऑपरेटर -> के ओवरलोडिंग की अनुमति देने का प्रस्ताव दिया।

इस उद्धरण में "मैं" Bjarne Stroustrup है। आप उससे अधिक आधिकारिक नहीं हो सकते हैं।

यदि आप वास्तव में सी ++ को समझना चाहते हैं (जैसा कि "यह ऐसा क्यों है"), आपको पूरी तरह से इस पुस्तक को पढ़ना चाहिए।

Answer 4

यह समझना बहुत आसान है, अगर आप ऑपरेटर फ़ंक्शन आमंत्रण के आंतरिक तंत्र से गुजरते हैं, कहें कि कक्षा परिसर में वास्तविक भाग के लिए दो सदस्य आर हो सकते हैं और मैं काल्पनिक भाग के लिए। कॉम्प्लेक्स सी 1 (10,20), सी 2 (10,2) // हम मानते हैं कि कक्षा में पहले से ही दो तर्क रचनाकार हैं। अब यदि आप सी 1 + सी 2 एक कथन के रूप में लिखते हैं तो संकलक जटिल संख्या पर + ऑपरेटर के अधिभारित संस्करण को खोजने का प्रयास करें। अब हम मानते हैं कि मैं अधिभार + ऑपरेटर, इसलिए सी 1 + सी 2 आंतरिक रूप से c1.operator + (c2) अब उन समयों के लिए मानें जिन्हें आप ओवरलोड कर सकते हैं। ' ऑपरेटर। तो अब कॉल C1.disp() एक जटिल ऑब्जेक्ट के // प्रदर्शन सामग्री अब एक आंतरिक प्रतिनिधित्व C1.operator के रूप में प्रतिनिधित्व करने के लिए कोशिश निम्नलिखित लगता है। (------), पूरी तरह से गंदा बातें बनाया। यही कारण है कि हम अधिभार नहीं कर सकते हैं। ' ऑपरेटर