एक साझा_ptr लौटने पर कॉन्वेंट रिटर्न प्रकार कैसे पूरा करें?

Question

using namespace boost; 

class A {}; 
class B : public A {}; 

class X { 
    virtual shared_ptr<A> foo(); 
}; 

class Y : public X { 
    virtual shared_ptr<B> foo(); 
}; 

रिटर्न प्रकार कॉन्वर्सेंट नहीं हैं (न ही वे कानूनी हैं), लेकिन वे होंगे यदि मैं इसके बजाय कच्चे पॉइंटर्स का उपयोग कर रहा था। यदि कोई है तो इसके आसपास काम करने के लिए आम तौर पर स्वीकार्य मुहावरे क्या है?

Answer 1

मुझे लगता है कि एक समाधान मौलिक रूप से असंभव है क्योंकि कॉन्वर्सिस पॉइंटर अंकगणित पर निर्भर करता है जो स्मार्ट पॉइंटर्स के साथ असंगत है।

जब Y::foo एक गतिशील फोन करने वाले को shared_ptr<B> देता है, यह उपयोग करने से पहले shared_ptr<A> लिए डाली जानी चाहिए। आपके मामले में, B* (शायद) को A* के रूप में पुनः परिभाषित किया जा सकता है, लेकिन एकाधिक विरासत के लिए, आपको C12+ को static_cast<A*>(shared_ptr<B>::get()) के बारे में बताने के लिए कुछ जादू की आवश्यकता होगी।

Answer 2

सीधे नहीं, लेकिन आप वास्तविक वर्चुअल फ़ंक्शंस को कक्षा के बाहर से पहुंचने और वर्चुअल फ़ंक्शन कॉल को गैर-वर्चुअल फ़ंक्शन में लपेटकर नकली बना सकते हैं। नकारात्मकता यह है कि आपको प्रत्येक व्युत्पन्न वर्ग पर इस रैपर फ़ंक्शन को लागू करना याद रखना होगा। लेकिन आप वर्चुअल फ़ंक्शन घोषणा और मैक्रो में रैपर दोनों डालकर इसे प्राप्त कर सकते हैं।

using namespace boost; // for shared_ptr, make_shared and static_pointer_cast. 

// "Fake" implementation of the clone() function. 
#define CLONE(MyType) \ 
    shared_ptr<MyType> clone() \ 
    { \ 
     shared_ptr<Base> res = clone_impl(); \ 
     assert(dynamic_cast<MyType*>(res.get()) != 0); \ 
     return static_pointer_cast<MyType>(res); \ 
    } 

class Base 
{ 
protected: 
    // The actual implementation of the clone() function. 
    virtual shared_ptr<Base> clone_impl() { return make_shared<Base>(*this); } 

public: 
    // non-virtual shared_ptr<Base> clone(); 
    CLONE(Base) 
}; 

class Derived : public Base 
{ 
protected: 
    virtual shared_ptr<Base> clone_impl() { return make_shared<Derived>(*this); } 

public: 
    // non-virtual shared_ptr<Derived> clone(); 
    CLONE(Derived) 
}; 


int main() 
{ 
    shared_ptr<Derived> p = make_shared<Derived>(); 
    shared_ptr<Derived> clone = p->clone(); 

    return 0; 
} 

Answer 3

मैं सिर्फ एक नंगे सूचक लौटाता हूं और इसे तुरंत साझा सूचक में लपेटता हूं।