क्या एक व्युत्पन्न वर्ग होना संभव है जो अंतिम कार्य प्राप्त करता है लेकिन एक ही कार्य बनाता है (ओवरराइड नहीं)?

Question

मुझे final फ़ंक्शन के साथ कोई समस्या है। मैं कक्षा में बहुरूपता को "रोकना" चाहता हूं लेकिन मैं अभी भी एक व्युत्पन्न वर्ग में एक ही कार्य उत्पन्न करना चाहता हूं।

कुछ इस तरह:

class Base{ 
    protected: 
     int _x, _y; 
    public: 
     Base(int x = 0, int y = 0) : _x(x), _y(y){}; 
     int x() const { return _x; } 
     int y() const { return _y; } 
     virtual void print()const{ cout << _x*_y << endl; } 
}; 

class Derived : public Base{ 
    public: 
     Derived(int x = 0, int y = 0) : Base(x, y){} 
     void print()const final { cout << _x*_y/2.0 << endl; } // final inheritance 
}; 

class NonFinal : public Derived{ 
     void print()const{ cout << "apparently im not the last..." << endl } 
    // here i want a new function. not overriding the final function from Derived class 
}; 

Answer 1

क्षमा करें, लेकिन यह संभव नहीं एक व्युत्पन्न वर्ग में एक समारोह बनाने के लिए एक ही नाम के साथ एक समारोह आधार वर्ग में final के रूप में मौजूद न होने पर है। आपको अपने डिजाइन पर पुनर्विचार करना होगा।

समस्या इस तथ्य से उत्पन्न होती है कि आधार वर्ग में फ़ंक्शन के समान नाम वाले व्युत्पन्न वर्ग में फ़ंक्शन घोषणा को ओवरराइड करने का प्रयास माना जाता है कि override कीवर्ड मौजूद है या नहीं (ऐतिहासिक कारणों से, मैं अनुमान)। तो आप ओवरराइडिंग "बंद" नहीं कर सकते हैं।

यहाँ एक प्रासंगिक मानक उद्धरण:

§ 10.3/4 [class.virtual]

कुछ वर्ग B में एक आभासी समारोह fvirt-विनिर्देशक के साथ चिह्नित है तोfinal और में एक DB से व्युत्पन्न D::fB::f ओवरराइड करता है, कार्यक्रम खराब हो गया है। [उदाहरण:

struct B { 
    virtual void f() const final; 
}; 
struct D : B { 
    void f() const; // error: D::f attempts to override final B::f 
}; 

अंत

Answer 2

मुझे लगता है कि यह एक प्रायोगिक सवाल यह है कि, के बाद से वास्तव में आप पर पुनर्विचार करना चाहिए तुम क्या कर रहे हैं जब आप "एक अंतिम समारोह को ओवरराइड करने के लिए" की आवश्यकता होती है (विरोधाभास लगता है, है ना?)।

लेकिन आप "डमी" -परमीटर, यानी void NonFinal::print(int test=0)const पेश कर सकते हैं, जो कि कंपाइलर सदस्य फ़ंक्शन को एक अलग के रूप में मानता है। सुनिश्चित नहीं है कि क्या आपकी "समस्या" हल हो जाती है; लेकिन कम से कम यह एक ही नाम के साथ एक समारोह पेश करता है, जिसे अभी भी एक तर्क पारित किए बिना बुलाया जा सकता है, और जिसे Derived और Base से अलग किया गया है।

class NonFinal : public Derived{ 
public: 
    void print(int test=0)const{ cout << "apparently im not the last..." << endl; } 
}; 

int main() { 

    Base b (10,10); 
    Derived d (20,20); 
    NonFinal nf; 
    Base *bPtr = &d; 
    bPtr->print(); // gives 200 
    bPtr = &nf; // gives 0 
    bPtr->print(); 
    nf.print(); // gives "apparantly..." 
}