रिटर्न प्रकार द्वारा निहित रूपांतरण सदस्य कार्य ओवरलोडिंग क्यों करते हैं, जबकि सामान्य कार्यों के लिए इसकी अनुमति नहीं है?

Question

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

क्या किसी को पता है क्यों? मैंने सोचा कि ऑपरेटरों को आंतरिक रूप से तरीकों से संभाला जाता है।

संपादित करें:

struct func { 
    operator string() { return "1";} 
    operator int() { return 2; } 
}; 

int main() { 
    int x = func(); // calls int version 
    string y = func(); // calls string version 
    double d = func(); // calls int version 
    cout << func() << endl; // calls int version 
} 

Answer 1

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

शब्दार्थ क्या अपने कोड क्या कर रहा है कई अलग जैसे रूपांतरण ऑपरेटरों और एक भी ऑपरेटर की भार के नहीं घोषित करने के लिए है।

Answer 2

कि वापसी प्रकार नहीं कर रहा है: यहाँ एक उदाहरण है। वह प्रकार का रूपांतरण है।

विचार करें: func() प्रकार func का एक ऑब्जेक्ट बनाता है। किस विधि (कन्स्ट्रक्टर) का आह्वान किया जाएगा इस पर कोई अस्पष्टता नहीं है।

एकमात्र प्रश्न जो बनी हुई है वह है कि इसे वांछित प्रकारों में डालना संभव हो। आपने संकलक को उपयुक्त रूपांतरण प्रदान किया है, इसलिए यह खुश है।

Answer 3

अधिभार संकल्प कई उम्मीदवार कार्यों के बीच चुनता है। इस प्रक्रिया में, उम्मीदवारों के वापसी प्रकार वास्तव में नहीं माना जाता है। हालांकि, रूपांतरण ऑपरेटरों के मामले में यह निर्धारित करने में "रिटर्न टाइप" गंभीर रूप से महत्वपूर्ण है कि क्या ऑपरेटर एक उम्मीदवार है या नहीं।

Answer 4

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

ध्यान दें कि आप तथ्य यह है कि निहित रूपांतरण उपयोगकर्ता परिणाम प्रकार पर अधिक भार अनुकरण करने के लिए definable हैं का उपयोग कर सकते हैं:

class CallFProxy; 
CallFProxy f(int); 

class CallFProxy { 
    int myParameter; 
    CallFProxy(int i) : myParameter(i) {} 
public: 
    operator double() { std::cout << "Calling f(int)->double\n"; return myParameter; } 
    operator string() { std::cout << "Calling f(int)->string\n"; return "dummy"; } 
};