Chiamata di funzione polimorfica senza codice duplicato

Question

Si supponga che tutte le classi di una gerarchia implementino una funzione membro modello g. Tutte le classi condividono la stessa realizzazione di altre due funzioni f1 e f2 che chiamano questo modello:

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; 
} 

Dal momento che le implementazioni di f1 e f2 sono identiche in tutte le classi, come posso liberarmi del codice duplicato ed ancora la chiamata polimorfica in main funziona come previsto (ovvero produce l'uscita "In B")?

Answer 1

noti che le implementazioni di f1 e f2 in A, B e C sono non identici. Limitiamolo a f1 s. Si chiama una funzione denominata ::A::g<int>, un'altra chiama una funzione denominata ::B::g<int> e la terza chiama una funzione denominata ::C::g<int>. Sono molto lontani da identici.

La migliore che si possa fare è avere una base di CRTP in stile:

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

Si può solo fattore le cose specifiche della classe che la funzione di modello utilizza, ad esempio (nel tuo esempio) il nome della classe :

#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(); }