सशर्त शुद्ध आधार वर्ग

Question

से विरासत मान लीजिए मैं निम्नलिखित वर्ग परिभाषाओं

है

struct base { 
    virtual int f() = 0; 
}; 

struct A: public base { 
    int f() final { return 1; } 
}; 

struct B: public base { 
    int f() final { return 2; } 
}; 

यह टेम्पलेट्स है कि एक bool पैरामीटर निर्दिष्ट करता है कि base या नहीं से विरासत के लिए कि क्या ले में A और B चालू करने के लिए संभव है? मेरे पास ऐसे मामले हैं जो एक सामान्य इंटरफ़ेस प्रदान करने वाले बेस क्लास की आवश्यकता नहीं करते हैं या नहीं।

मान लें कि A और B में बहुत से सदस्य कार्य हैं, इसलिए डुप्लीकेटिंग कार्यान्वयन कठिन होगा। लेकिन sizeof(A) और sizeof(B) छोटे हैं।

Answer 1

मैं कोड डुप्लिकेशंस के बिना, अधिक प्रत्यक्ष दृष्टिकोण के साथ आया था।

struct base { 
    virtual int f() = 0; 
}; 

struct empty_base { }; 

template <bool Inherit> 
struct A final: public std::conditional_t<Inherit,base,empty_base> { 
    int f() { return 1; } 
}; 

Answer 2

ज़रूर:

template <bool> struct A 
{ 
    // ... 
}; 

template <> struct A<true> : base 
{ 
    // ... 
}; 

(ध्यान दें कि आप बना सकते हैं कि A<true>A<false> से निकाले जाते हैं कि अगर अतिरेक से बचा जाता है।)

उदाहरण के लिए:

template <bool> struct A 
{ 
    void f() { std::cout << "A::f called\n"; } 
}; 

template <> struct A<true> : A<false>, base 
{ 
    void f() override { A<false>::f(); } 
}; 

int main() 
{ 
    A<false> a1; 
    A<true> a2; 
    a1.f(); 
    a2.f(); 
    static_cast<base&>(a2).f(); 
} 

Answer 3

आप एक शुद्ध आधार का उपयोग कर रहे के बाद से क्लास भेद महत्वपूर्ण नहीं होना चाहिए क्योंकि जब आप A::f() पर कॉल करते हैं तो आपके ऑप्टिमाइज़र वर्चुअल फ़ंक्शन कॉल से बचेंगे क्योंकि वाई कभी भी व्युत्पन्न कक्षा नहीं होगी जो f() के एक अलग संस्करण को लागू करेगी।

यदि आप प्रत्येक कार्य में final जोड़ने से बचने के लिए A से विरासत में रहने की योजना नहीं बनाते हैं तो आप class A final : base भी कर सकते हैं।