सी ++: निजी आभासी कार्यों बनाम शुद्ध आभासी कार्यों

Question

संभव डुप्लिकेट:
Private virtual method in C++

अगर मैं इस पोस्ट (Private virtual method in C++) से सही ढंग से समझ में आया, एक आधार वर्ग में एक आभासी समारोह बनाने व्युत्पन्न कक्षाएं इसे ओवरराइड करने में सक्षम बनाती हैं। लेकिन ऐसा लगता है कि चीजें वहां रुकती हैं।

लेकिन यदि बेस क्लास वर्चुअल फ़ंक्शन शुद्ध है, तो व्युत्पन्न कक्षाओं को फ़ंक्शन को लागू करने के लिए मजबूर करता है। इसलिए, एक शुद्ध (सार्वजनिक) वर्चुअल फ़ंक्शन केवल एक इंटरफ़ेस है। मैं यहां एक लाभ देख सकता हूं।

दूसरी तरफ, बेस क्लास वर्चुअल फ़ंक्शन निजी बनाकर, केवल व्युत्पन्न वर्ग को फ़ंक्शन को ओवरराइड करने की क्षमता देता है, लेकिन मुझे इसका कोई फायदा नहीं होता है। ऐसा लगता है कि वह निजी वर्चुअल फ़ंक्शन भी वहां नहीं है। व्युत्पन्न वर्ग स्पष्ट रूप से बेस क्लास में उस वर्चुअल फ़ंक्शन के अस्तित्व के बारे में नहीं जानता है क्योंकि इसका निजी, तो विरासत या बहुरूपता की अवधि में बेस क्लास निजी फ़ंक्शन वर्चुअल घोषित करने का कोई लाभ है?

इसके अलावा, क्या कोई ऐसी स्थिति है जहां बेस क्लास एक 'शुद्ध आभासी' और 'निजी' कार्य घोषित करेगी?

धन्यवाद।

Answer 1

एक लाभ template method pattern को लागू करने में है:

class Base { 

public : 
    void doSomething() { 
    doSomething1(); 
    doSomething2(); 
    doSomething3(); 
    } 
private: 
    virtual void doSomething1()=0; 
    virtual void doSomething2()=0; 
    virtual void doSomething3()=0; 
}; 


class Derived : public Base { 
    private: 
    virtual void doSomething1() { ... } 
    virtual void doSomething2() { .... } 
    virtual void doSomething3() { .... } 
} 

यह जबकि आधार वर्ग निर्धारित करता है कि इन टुकड़ों को एक साथ रखा है, व्युत्पन्न वर्ग एक निश्चित तर्क के प्रत्येक टुकड़े को लागू करने की अनुमति देता है। और चूंकि टुकड़े खुद से समझ में नहीं आता है, इसलिए उन्हें private घोषित किया जाता है और इसलिए क्लाइंट कोड से छुपाया जाता है।

Answer 2

यदि विधि आभासी है तो इसे व्युत्पन्न कक्षाओं द्वारा ओवरराइड किया जा सकता है, भले ही यह निजी हो। वैसे भी, इसे संरक्षित के साथ घोषित किया जाना चाहिए।

Answer 3

यह उन परिस्थितियों के लिए है जो आधार चाहते हैं कि उनके बच्चे कार्यक्षमता को कार्यान्वित करें जो आधार को स्वयं उपयोग करने की आवश्यकता है। एक मूर्ख उदाहरण की कल्पना करो - कारें।

class Car { 
public: 
    int getTorque(); 
    int getPower(); 

private: 
    virtual const Engine& gimmeEngine() = 0; 
}; 

class Ferrari : public Car { 
private: 
    FerrariEngine myCoolEngine; 
    const Engine& gimmeEngine() { return myCoolEngine; } 
}; 

अब कार, फेरारी के इंजन के बारे में कुछ भी पता की जरूरत नहीं है केवल कि यह कुछ Engine इंटरफ़ेस guaranties है कि कि Car अपनी शक्ति और टॉर्क के बारे में जानकारी प्राप्त कर सकते हैं लागू करता है।

इस मूर्ख उदाहरण में getTorque और getPower शुद्ध आभासी बनाकर सब कुछ सरल बनाया जा सकता है, लेकिन मुझे उम्मीद है कि यह विचार को दर्शाता है। Base को कुछ विशिष्ट तर्कों का उपयोग करने की आवश्यकता है प्रत्येक बच्चे के पास जानता है, इसलिए यह एक निजी शुद्ध आभासी सदस्य के माध्यम से पूछताछ करता है।