डुप्लिकेट कोड

Question

के बिना पॉलिमॉर्फिक फ़ंक्शन कॉल मान लीजिए कि पदानुक्रम के सभी वर्ग टेम्पलेट सदस्य फ़ंक्शन g लागू करते हैं। कैसे मैं डुप्लिकेट कोड से छुटकारा और अभी भी प्राप्त कर सकते हैं

struct A { 
    virtual void f1() { 
     g(5); 
    } 
    virtual void f2() { 
     g(5.5); 
    } 
private: 
    template <typename T> void g(T) {std::cout << "In A" << std::endl;} 
}; 

struct B: A { 
    // Can I get rid of this duplicate code? 
    virtual void f1() { 
     g(5); 
    } 
    virtual void f2() { 
     g(5.5); 
    } 
private: 
    template <typename T> void g(T) {std::cout << "In B" << std::endl;} 
}; 

struct C: A { 
    // Can I get rid of this duplicate code? 
    virtual void f1() { 
     g(5); 
    } 
    virtual void f2() { 
     g(5.5); 
    } 
private: 
    template <typename T> void g(T) {std::cout << "In C" << std::endl;} 
}; 

int main() 
{ 
    B b; 
    A &a = b; 
    a.f1(); 
    return 0; 
} 

f1 और f2 के कार्यान्वयन के बाद से सभी वर्गों में समान हैं,: सभी वर्गों दो अन्य कार्यों f1 और f2 कि इस टेम्पलेट फोन का एक ही कार्यान्वयन का हिस्सा main में पॉलिमॉर्फिक कॉल अपेक्षित काम करता है (यानी आउटपुट "बी में" उत्पादन)?

Answer 1

ध्यान दें कि f1 और f2A में, B, और C के कार्यान्वयन नहीं समान हैं। आइए इसे f1 एस तक सीमित करें। एक ::A::g<int> नामक फ़ंक्शन को कॉल करता है, दूसरा एक ::B::g<int> नामक फ़ंक्शन को कॉल करता है, और तीसरा व्यक्ति ::C::g<int> नामक फ़ंक्शन को कॉल करता है। वे समान से बहुत दूर हैं। (अपने उदाहरण में)

template <class Derived> 
struct DelegateToG : public A 
{ 
    void f1() override 
    { 
    static_cast<Derived*>(this)->g(5); 
    } 

    void f2() override 
    { 
    static_cast<Derived*>(this)->g(5.5); 
    } 
}; 

class B : public DelegateToG<B> 
{ 
    friend DelegateToG<B>; 
private: 
    template <class T> void g(T) { /*...*/ } 
}; 

class C : public DelegateToG<C> 
{ 
    friend DelegateToG<C>; 
private: 
    template <class T> void g(T) { /*...*/ } 
}; 

Answer 2

तुम सिर्फ वर्ग विशेष बातें टेम्पलेट समारोह का उपयोग करता है, इस तरह के रूप में बाहर कारक बन सकते हैं वर्ग के नाम:

सबसे अच्छा तुम कर सकते हो एक CRTP शैली आधार है :

#include <iostream> 
using namespace std; 

class A 
{ 
private: 
    virtual auto classname() const -> char const* { return "A"; } 

protected: 
    template <typename T> void g(T) {cout << "In " << classname() << endl;} 

public: 
    virtual void f1() { g(5); } 
    virtual void f2() { g(5.5); } 
}; 

class B 
    : public A 
{ 
private: 
    auto classname() const -> char const* override { return "B"; } 
}; 

class C 
    : public A 
{ 
private: 
    auto classname() const -> char const* override { return "C"; } 
}; 

auto main() 
    -> int 
{ static_cast<A&&>(B()).f1(); }