सी ++ आपको सबसे ज्यादा व्युत्पन्न कक्षा में पॉइंटर का अनुरोध करने की अनुमति क्यों नहीं देता है?

Question

(यह सवाल शायद Stroustrup के लिए एक संदर्भ के साथ उत्तर दिया जाना चाहिए।)

यह के रूप में, सबसे व्युत्पन्न वर्ग के सूचक के अनुरोध करने के लिए निम्नलिखित सक्षम होने के लिए अत्यंत उपयोगी लगता है:

class Base { ... }; 
class DerivedA { ... }; 
class DerivedB { ... }; 
class Processor 
{ 
    public: 
    void Do(Base* b) {...} 
    void Do(DerivedA* d) {...} 
    void Do(DerivedB* d) {...} 
}; 

list<Base*> things; 
Processor p; 
for(list<Base*>::iterator i=things.begin(), e=things.end(); i!=e; ++i) 
{ 
    p.Do(CAST_TO_MOST_DERIVED_CLASS(*i)); 
} 

लेकिन यह तंत्र सी ++ में प्रदान नहीं किया गया है। क्यूं कर?

अद्यतन, प्रेरित उदाहरण: के बजाय बेस होने के

मान लीजिए और व्युत्पन्न और प्रोसेसर, तुम हो:

class Fruit 
class Apple : public Fruit 
class Orange: public Fruit 

class Eater 
{ 
    void Eat(Fruit* f) { ... } 
    void Eat(Apple* f) { Wash(f); ... } 
    void Eat(Orange* f) { Peel(f); ... } 
}; 

Eater me; 
for each Fruit* f in Fruits 
    me.Eat(f); 

लेकिन यह सी में करने के लिए ++ मुश्किल है, आगंतुक की तरह रचनात्मक समाधान की आवश्यकता होती है पैटर्न। सवाल यह है कि: सी ++ में ऐसा करना मुश्किल क्यों है, जब "CAST_TO_MOST_DERIVED" जैसी कुछ चीज़ इसे अधिक सरल बनाती है?

अपडेट: विकिपीडिया सभी

मुझे लगता है कि पुन्तुस Gagge एक अच्छा जवाब है जानता है। यह करने के लिए Multiple Dispatch पर विकिपीडिया प्रविष्टि से इस बिट जोड़ें:

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

पृष्ठभूमि के लिए, आप Multi-Methods के बारे में थोड़ा सारांश है, जो एक मैं उल्लेख की तरह एक फोन से बेहतर होगा, क्योंकि वे सिर्फ काम करेंगे पढ़ सकते हैं।

Answer 1

क्या आप क्रम प्रकार पर एक switch के बराबर होगा सुझाव दे रहे हैं, अतिभारित कार्यों में से एक करार दिया। के रूप में दूसरों का संकेत दिया है, तो आप अपने वंशानुगत पदानुक्रम के साथ काम करना चाहिए, और नहीं के खिलाफ यह: अपने वर्ग पदानुक्रम के बजाय इसे बाहर भेजने में virtuals का उपयोग करें।

उसने कहा, ऐसा कुछ double dispatch के लिए उपयोगी हो सकता है, खासकर यदि आपके पास Processors का पदानुक्रम भी है। लेकिन संकलक इसे कैसे कार्यान्वित करेगा?

सबसे पहले, आप को निकालने के लिए क्या आप क्रम में 'सबसे अतिभारित प्रकार' फोन होगा। यह किया जा सकता है, लेकिन आप कैसे निपटेंगे उदा। एकाधिक विरासत और टेम्पलेट्स? किसी भाषा में प्रत्येक सुविधा को अन्य सुविधाओं के साथ अच्छी तरह से बातचीत करनी चाहिए - और सी ++ में बड़ी संख्या में विशेषताएं हैं!

दूसरा, अपने कोड उदाहरण काम करने के लिए, आप क्रम प्रकार के आधार पर सही स्थिर अधिभार भी प्राप्त करना होगा (जो सी ++ की अनुमति नहीं है के रूप में यह डिज़ाइन किया गया है)। क्या आप इसे compile time lookup rules का पालन करना चाहते हैं, खासकर एकाधिक पैरामीटर के साथ? क्या आप इस रनटाइम प्रेषण को अपने Processor पदानुक्रम के रनटाइम प्रकार पर विचार करने के लिए पसंद करेंगे, और उन्होंने क्या अधिभार जोड़ा है? आप अपने रनटाइम प्रेषक में स्वचालित रूप से जोड़ने के लिए संकलक को कितना तर्क पसंद करेंगे? आप अमान्य रनटाइम प्रकारों से कैसे निपटेंगे? क्या फीचर के उपयोगकर्ता साधारण कलाकार और फ़ंक्शन कॉल की तरह दिखने की लागत और जटिलता से अवगत होंगे?

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

Answer 2

इसे वर्चुअल फ़ंक्शन कॉल का उपयोग करने के लिए कहा जाता है। प्रोसेसर * डेरिवेटा/बी की आभासी विधि में पास करें। कोई और रास्ता नही।

कोई तंत्र प्रदान नहीं किया गया है क्योंकि यह पूरी तरह से अनावश्यक और अनावश्यक है।

मैं कसम खाता हूं, मैंने एक या दो दिन पहले इस सटीक प्रश्न को मैदान में रखा था।

Answer 3

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

Answer 4

क्योंकि मेरा प्रकार संकलन समय पर निर्धारित नहीं है। इसलिए संकलक नहीं जानता कि कौन सा फ़ंक्शन कॉल उत्पन्न होता है। सी ++ केवल गतिशील प्रेषण की एक विधि का समर्थन करता है जो वर्चुअल फ़ंक्शन तंत्र है।

Answer 5

सी ++ संबंधित प्रकार के संदर्भ में डेटा का अर्थ देता है। जब आप किसी सूची में DerivedA * या DerivedB * का एक उदाहरण संग्रहीत करते हैं, तो उस सहयोगी प्रकार को आवश्यक रूप से बेस * होना चाहिए। इसका मतलब यह है कि संकलक स्वयं यह निर्धारित नहीं कर सकता कि वे बेस क्लास के बजाय उप-वर्गों में से एक के लिए पॉइंटर्स हैं।सिद्धांत रूप में आप संबंधित प्रकार की विरासत को देखकर एक कम व्युत्पन्न वर्ग में जा सकते हैं, जो आप चाहते हैं उसे करने के लिए आवश्यक जानकारी संकलन-समय पर उपलब्ध नहीं है।

Answer 6

सबसे पहले, सी ++ आपको संख्यात्मक शर्तों (यानी केवल पते का संख्यात्मक मान) में सबसे अधिक व्युत्पन्न कक्षा में सूचक के लिए अनुरोध करने की अनुमति देता है। यह dynamic_cast से void* करता है।

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

,, पूरी तरह से अलग तरह से कार्यान्वित किया जाता है क्या आप को लागू करने (अगर मैं अपने इरादे को सही ढंग से समझ में आ) की कोशिश कर रहे एक कलाकारों द्वारा नहीं। एक उदाहरण के लिए डबल प्रेषण पढ़ें।

Answer 7

सी ++ ओवरलोड रिज़ॉल्यूशन संकलन समय पर होता है। आपके उदाहरण को रनटाइम पर *i के वास्तविक प्रकार का निर्धारण करने की आवश्यकता होगी। रनटाइम पर इसे करने के लिए रनटाइम प्रकार की जांच की आवश्यकता होगी, और क्योंकि सी ++ एक प्रदर्शन उन्मुख भाषा है, यह उद्देश्य से इस लागत से बचाता है। यदि आप वास्तव में ऐसा करना चाहते थे (और मैं एक और यथार्थवादी उदाहरण देखने के लिए उत्सुक हूं) तो आप सबसे व्युत्पन्न वर्ग में गतिशील_कास्ट कर सकते हैं, फिर यदि वह दूसरी सबसे व्युत्पन्न कक्षा में विफल रहता है, और इसी तरह, लेकिन इसके बारे में जानने की आवश्यकता है सामने पदानुक्रम ऊपर। और पूर्ण पदानुक्रम को आगे बढ़ना असंभव हो सकता है - यदि डेरिवेटबी कक्षा सार्वजनिक हेडर में है, तो संभव है कि एक और लाइब्रेरी इसका उपयोग करे और एक और अधिक व्युत्पन्न वर्ग बनाये।

Answer 8

आप double dispatch देख रहे हैं। यह सी ++ में किया जा सकता है, जैसा कि उस लिंक पर दिखाया गया है, लेकिन यह सुंदर नहीं है, और इसमें मूल रूप से एक दूसरे को कॉल करने वाले दो आभासी कार्यों का उपयोग करना शामिल है। यदि आप अपने विरासत के पेड़ में कुछ वस्तुओं को संशोधित नहीं कर सकते हैं, तो आप इस तकनीक का उपयोग करने में सक्षम नहीं हो सकते हैं।

Answer 9

यह सी ++ में संभव नहीं है, लेकिन क्या हासिल करना चाहते हैं का उपयोग कर आसानी से संभव है Visitor design pattern:

class Base 
{ 
    virtual void accept(BaseVisitor& visitor) { visitor.visit(this); } 
}; 

class DerivedA 
{ 
    virtual void accept(BaseVisitor& visitor) { visitor.visit(this); } 
}; 

class DerivedB 
{ 
    virtual void accept(BaseVisitor& visitor) { visitor.visit(this); } 
}; 

class BaseVisitor 
{ 
    virtual void visit(Base* b) = 0; 
    virtual void visit(DerivedA* d) = 0; 
    virtual void visit(DerivedB* d) = 0; 
}; 

class Processor : public BaseVisitor 
{ 
    virtual void visit(Base* b) { ... } 
    virtual void visit(DerivedA* d) { ... } 
    virtual void visit(DerivedB* d) { ... } 
}; 

list<Base*> things; 
Processor p; 
for(list<Base*>::iterator i=things.begin(), e=things.end(); i!=e; ++i) 
{ 
    (*i)->visit(p); 
} 

Answer 10

करता क्यों नहीं सी ++ यह है? शायद रचनाकारों ने कभी इसके बारे में सोचा नहीं। या शायद वे इसे उपयुक्त या उपयोगी नहीं मानते थे। या शायद इस भाषा में इसे करने की कोशिश करने में समस्याएं थीं।

चलें कहना इस सुविधा मौजूद है ताकि संकलक कोड गतिशील प्रकार की ओर इशारा किया की जांच करता है और उचित अधिभार कॉल लिखेंगे:

कि पिछले संभावना पर, यहाँ एक सोचा प्रयोग है। अब यह भी कहें कि कोड का एक अलग भाग class DerivedC : Base {...}; है। और कहें कि संबंधित Processor::Do अधिभार जोड़ा गया है।

यह सब देखते हुए, उचित अधिभार चुनने का प्रयास करते समय प्रोग्राम को क्या करना चाहिए? इस विसंगति को संकलन समय पर पकड़ा नहीं जा सकता है। क्या इसे बेस क्लास से मेल खाने वाले फ़ंक्शन को खोजने के लिए क्लास पदानुक्रम पर चढ़ने की कोशिश करनी चाहिए? क्या यह एक विशेष अपवाद फेंकना चाहिए? क्या यह सिर्फ दुर्घटनाग्रस्त होना चाहिए? क्या कोई और संभावना है? क्या वास्तव में कोई उचित विकल्प है कि संकलक आपके कोड और वर्ग पदानुक्रम के इरादे को जानने के बिना स्वयं ही बना सकता है?

हां, ऐसी कार्यक्षमता लिखना स्वयं एक ही समस्या के लिए अतिसंवेदनशील होगा, लेकिन वहां प्रोग्रामर का व्यवहार चुनने के लिए कुल नियंत्रण होता है, न कि संकलक।