क्या ऑब्जेक्ट समतुल्य के लिए पॉलिमॉर्फिक प्रकार की तुलना करने के लिए सी ++ में एक मूर्खतापूर्ण दृष्टिकोण है?

Question

मेरे पास पॉलिमॉर्फिक प्रकार के दो उदाहरणों के लिए आधार * पॉइंटर्स हैं और मुझे यह निर्धारित करने की आवश्यकता है कि संदर्भित वस्तुएं बराबर हैं या नहीं।

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

क्या कोई और मूर्खतापूर्ण दृष्टिकोण है?

Answer 1

व्युत्पन्न वर्ग से ज्यादातर के लिए, बराबर का अर्थ है कि सदस्य चर सभी एक ही मूल्य

C++ में इस 'समानता' कहा जाता है और आम तौर पर operator==() का उपयोग कर कार्यान्वित किया जाता है।

MyType A; 
MyType B; 
if (A == B) { 
    // do stuff 
} 

और == कॉल आपके द्वारा निर्धारित एक कस्टम समारोह है: सी ++ आप ऑपरेटरों के अर्थ ओवरराइड कर सकते हैं के लिए, यह लिखने के लिए संभव है।

मुझे लगता है कि आप पहचान से समानता को अलग करना चाहते हैं जिसका अर्थ एक ही वस्तु (यानी एक ही पता) होगा।

आप सदस्य समारोह या मुक्त समारोह (विकिपीडिया से) के रूप में इसे लागू कर सकते हैं:

bool T::operator ==(const T& b) const; 
bool operator ==(const T& a, const T& b); 

अपने मामले में आप आधार वर्ग के लिए operator== लागू करना चाहते हैं, और उसके बाद प्रदर्शन करते हैं कि आप क्या कर रहे हैं।

अधिक वस्तुतः यह इस तरह दिखेगा:

class MyBase 
{ 
    virtual ~MyBase(); // reminder on virtual destructor for RTTI 
    // ... 
private: 
    virtual bool is_equal(const MyBase& other); 

    friend bool operator ==(const MyBase& a, const MyBase& b); 

    // ...  
}; 

bool operator ==(const MyBase& a, const MyBase& b) 
{ 
    // RTTI check 
    if (typeid(a) != typeid(b)) 
     return false; 
    // Invoke is_equal on derived types 
    return a.is_equal(b); 
} 


class D1 : MyBase 
{ 
    virtual bool is_equal(const Base& other) 
    { 
     const D1& other_derived = dynamic_cast<const D1&>(other); 
     // Now compare *this to other_derived 
    } 
}; 

class D2 : MyBase; 
{ }; 


D1 d1; D2 d2; 
bool equal = d1 == d2; // will call your operator and return false since 
         // RTTI will say the types are different