सी ++ कंपाइलर अंतिम गति से इस गतिशील_कास्ट को अनुकूलित क्यों नहीं करते हैं?

Question

इस वर्ग पदानुक्रम पर विचार करें:

struct Animal { virtual ~Animal(); }; 
struct Cat : virtual Animal {}; 
struct Dog final : virtual Animal {}; 

मेरे समझ class Dog पर final डाल सुनिश्चित करता है कि कि कोई भी कभी भी एक वर्ग Dog है, जो, परिणाम है, जिसका अर्थ है कि कोई भी कभी भी एक वर्ग है कि गया-एक ऐसा बना सकते हैं से इनहेरिट बना सकते हैं Dog और आईएस-ए Cat एक साथ।

पर विचार इन दोनों dynamic_cast रों:

Dog *to_final(Cat *c) { 
    return dynamic_cast<Dog*>(c); 
} 

Cat *from_final(Dog *d) { 
    return dynamic_cast<Cat*>(d); 
} 

जीसीसी, आईसीसी, और MSVC final क्वालीफायर ध्यान न दें और __dynamic_cast के लिए एक कॉल उत्पन्न; यह दुर्भाग्यपूर्ण है लेकिन आश्चर्य की बात नहीं है।

क्या मुझे आश्चर्य है कि बजना और Zapcc from_final के लिए दोनों generate इष्टतम कोड ("हमेशा nullptr वापसी"), लेकिन to_final के लिए __dynamic_cast के लिए एक कॉल उत्पन्न है।

यह वास्तव में एक चूक अनुकूलन अवसर (एक संकलक जहां स्पष्ट रूप से किसी डाले में final क्वालीफायर सम्मान में कुछ प्रयास डाल में) है, या कुछ सूक्ष्म कारण यह है कि मैं अभी भी नहीं कर रहा हूँ के लिए इस मामले में अनुकूलन असंभव है देख के?

Answer 1

ठीक है, मैं बजना के source code to find this method के माध्यम से खोदा:

/// isAlwaysNull - Return whether the result of the dynamic_cast is proven 
/// to always be null. For example: 
/// 
/// struct A { }; 
/// struct B final : A { }; 
/// struct C { }; 
/// 
/// C *f(B* b) { return dynamic_cast<C*>(b); } 
bool CXXDynamicCastExpr::isAlwaysNull() const 
{ 
    QualType SrcType = getSubExpr()->getType(); 
    QualType DestType = getType(); 

    if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) { 
    SrcType = SrcPTy->getPointeeType(); 
    DestType = DestType->castAs<PointerType>()->getPointeeType(); 
    } 

    if (DestType->isVoidType()) // always allow cast to void* 
    return false; 

    const CXXRecordDecl *SrcRD = 
    cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl()); 

    //******************************************************************** 
    if (!SrcRD->hasAttr<FinalAttr>()) // here we check for Final Attribute 
    return false; // returns false for Cat 
    //******************************************************************** 

    const CXXRecordDecl *DestRD = 
    cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl()); 

    return !DestRD->isDerivedFrom(SrcRD); // search ancestor types 
} 

मैं कोड को पार्स से थोड़ी थक हो रही है, लेकिन यह मुझे नहीं लगता है कि आपके from_final अंतिम की वजह से बस हमेशा रिक्त नहीं है विशेषता, लेकिन इसके अतिरिक्त क्योंकि CatDog व्युत्पन्न रिकॉर्ड श्रृंखला में नहीं है। अनुमोदित, अगर इसमें final विशेषता नहीं थी, तो यह जल्दी से बाहर निकलती थी (जैसा कि Cat एक एसआरसी है), लेकिन यह हमेशा जरूरी नहीं होता।

मुझे लगता है कि इसके लिए कुछ कारण हैं। पहला यह है कि गतिशील_कास्ट रिकॉर्ड श्रृंखला को ऊपर और नीचे दोनों बनाता है। जब स्रोत रिकॉर्ड में अंतिम विशेषता होती है, तो यदि आप एक पूर्वजों (यदि स्रोत से कोई व्युत्पन्न कक्षा नहीं हो सकती है) तो आप केवल श्रृंखला की जांच कर सकते हैं।

लेकिन क्या होगा यदि कक्षा अंतिम नहीं है? मुझे संदेह है कि इसमें और भी कुछ हो सकता है। हो सकता है कि एकाधिक विरासत खोजों को नीचे की तुलना में अधिक कठिन बना देता है? डीबगर में कोड को रोक दिए बिना, मैं बस इतना कर सकता हूं।

यह मुझे पता है: isAlwaysNull एक प्रारंभिक निकास समारोह है। यह एक उचित दावा है कि यह साबित करने की कोशिश कर रहा है कि परिणाम हमेशा शून्य है। आप नकारात्मक साबित नहीं कर सकते (जैसा कि वे कहते हैं), लेकिन आप सकारात्मक को अस्वीकार कर सकते हैं।

---

शायद आप फ़ाइल के लिए Git इतिहास की जांच और जो व्यक्ति कि समारोह लिखा ईमेल कर सकते हैं। (या कम से कम final चेक जोड़ा गया)।