सी ++: मैं बिना किसी कास्टिंग के विरासत में कक्षाओं में "अवैध कॉन्वेंट रिटर्न प्रकार" से कैसे बच सकता हूं?

Question

मेरे पास एक जटिल श्रेणी पदानुक्रम है जिसमें कक्षाएं एक-दूसरे के आधार पर क्रॉस-जैसी हैं: दो अमूर्त कक्षाएं ए और सी में एक विधि है जो क्रमशः सी और ए का उदाहरण देता है। विरासत में कक्षाओं में मैं एक सह-प्रकार का उपयोग करना चाहता हूं, जो इस मामले में एक समस्या है क्योंकि मुझे विरासत संबंध जहाज को आगे बढ़ाने का तरीका नहीं पता है।

मुझे एक "test.cpp: 22: त्रुटि प्राप्त होती है: 'वर्चुअल डी * बी :: आउटसी()' के लिए अमान्य कॉन्वर्सट रिटर्न टाइप" - त्रुटि क्योंकि संकलक को पता नहीं है कि डी सी

का उप-वर्ग है

class C; 

class A { 
public: 
     virtual C* outC() = 0; 
}; 

class C { 
public: 
     virtual A* outA() = 0; 
}; 


class D; 

class B : public A { 
public: 
     D* outC(); 
}; 

class D : public C { 
public: 
     B* outA(); 
}; 

D* B::outC() { 
     return new D(); 
} 

B* D::outA() { 
     return new B(); 
} 

यदि मैं वापसी प्रकार बी :: आउटसी() से सी * को उदाहरण संकलित करता हूं। बी * और डी * को विरासत कक्षाओं में रिटर्न प्रकार के रूप में रखने का कोई तरीका है (यह मेरे लिए सहज होगा कि एक तरीका है)?

Answer 1

पर एक नज़र डालें I C++ में सीधे युग्मित कॉन्वेंट सदस्यों को रखने का कोई तरीका नहीं है। आपके पास या तो एक परत जोड़ने के लिए होगा, या कॉन्वरेन्ट को अपने आप को वापस लागू करें।

पहला विकल्प

class C; 

class A { 
public: 
     virtual C* outC() = 0; 
}; 

class C { 
public: 
     virtual A* outA() = 0; 
}; 


class BI : public A { 
public: 
}; 

class D : public C { 
public: 
     BI* outA(); 
}; 

class B: public BI { 
public: 
     D* outC(); 
}; 

D* B::outC() { 
     return new D(); 
} 

BI* D::outA() { 
     return new B(); 
} 

के लिए और के लिए दूसरे

class C; 

class A { 
public: 
     C* outC() { return do_outC(); } 
     virtual C* do_outC() = 0; 
}; 

class C { 
public: 
     virtual A* outA() = 0; 
}; 


class D; 

class B : public A { 
public: 
     D* outC(); 
     virtual C* do_outC(); 
}; 

class D : public C { 
public: 
     B* outA(); 
}; 

D* B::outC() { 
     return static_cast<D*>(do_outC()); 
} 

C* B::do_outC() { 
     return new D(); 
} 

B* D::outA() { 
     return new B(); 
} 

नोट

कि इस दूसरा विकल्प क्या परोक्ष (कि static_cast मान्य है कुछ स्थिर चेकों के साथ) संकलक द्वारा किया जाता है है ।

Answer 2

क्लाइंट साइड अपेक्षा के कारण आप ऐसा नहीं कर सकते हैं। सी उदाहरण का उपयोग करते समय, आप यह नहीं बता सकते कि यह किस प्रकार का सी है (एक डी या कुछ और)। इस प्रकार, यदि आप बी पॉइंटर को स्टोर करते हैं (एक कॉल से व्युत्पन्न कक्षा में कॉल करते हैं लेकिन आप संकलन समय पर इसे नहीं जानते हैं) एक पॉइंटर में, मुझे यकीन नहीं है कि सभी मेमोरी सामान सही होंगे।

जब आप पॉलिमॉर्फिक प्रकार पर कोई विधि कॉल करते हैं, तो रनटाइम पर्यावरण को ऑब्जेक्ट के डायनामिक प्रकार की जांच करनी होती है और यह पॉइंटर्स को आपके क्लास पदानुक्रम के अनुरूप ले जाती है। मुझे यकीन नहीं है कि आपको कॉन्वर्सिस पर भरोसा करना चाहिए। this

Answer 3

जहां तक ​​मुझे पता है, स्पष्ट कास्टिंग के बिना ऐसा करने का कोई तरीका नहीं है। समस्या वर्ग B की परिभाषा जानते हैं कि नहीं कर सकते कि DC का एक उपवर्ग है जब तक यह वर्ग D की एक पूरी परिभाषा देखता है, लेकिन वर्ग D की परिभाषा पता नहीं कर सकते हैं कि BA का एक उपवर्ग है जब तक यह देखता है कक्षा B की पूर्ण परिभाषा, और इसलिए आपके पास गोलाकार निर्भरता है। इसे आगे की घोषणाओं के साथ हल नहीं किया जा सकता है क्योंकि दुर्भाग्यवश एक अग्रिम घोषणा विरासत संबंध निर्दिष्ट नहीं कर सकती है।

टेम्पलेट्स, which I found can be solved का उपयोग कर एक कॉन्वेंट clone() विधि को कार्यान्वित करने की कोशिश करने में एक ही समस्या है, लेकिन समान समाधान अभी भी विफल रहता है क्योंकि परिपत्र संदर्भ हल करना असंभव है।