Polimorfismo C++ statico piuttosto che dinamico

Question

Sto provando a creare un algoritmo generico. Finora ho raggiunto questo gerarchia di classi utilizzando e puntatori, come nell'esempio qui sotto:

struct Base{ 
    virtual double fn(double x){return 0;} 
}; 

class Derived : public Base{ 
    double A; 
public: 
    Derived(double a) : A(a) {} 
    double fn(double x) { return A*x;} 
}; 

//Some other implementations 

class algo{ 
    double T; 
    std::unique_ptr<Base> b_ptr; 
public: 
    algo(double t, std::unique_ptr<Base>& _ptr); //move constructor... 
    //Some constructors 
    double method(double x){ return T*b_ptr->fn(x);} 

}; 

Questo set up viene quindi implementato come segue:

int main(){ 
    std::unique_ptr<Derived> ptr(new Derived(5.4)); 
    algo(3.2,ptr); 
    method(2.4); 

    return 0; 
} 

Questo è un esempio molto semplice, naturalmente , ma serve per la mia domanda. Da quello che ho capito, l'uso di classi derivate in questo modo significa che il metodo viene scelto in fase di esecuzione piuttosto che in fase di compilazione. Dal momento che non ho bisogno di alcun comportamento dinamico dal mio algoritmo - tutto è determinato al momento della compilazione - questa è una perdita inutile di efficienza. C'è un modo per fare quanto sopra al momento della compilazione, cioè il polimorfismo statico?

Da quello che ho capito, è possibile ottenere solo il polimorfismo statico utilizzando i modelli. Tuttavia, non sono stato in grado di trovare modelli di attrezzo con tipi non primitivi. Come nell'esempio sopra, ho bisogno di classi derivate con costruttori non predefiniti, il che non sembra possibile ... Qualcuno potrebbe offrire qualche soluzione su come ciò potrebbe essere fatto?

Answer 1

classe base e derivato sembrano rappresentare una funzione solo avere una sola funzione membro, così abbiamo potuto probabilmente fare a meno il polimorfismo completamente e passare una funzione in algo:

#include <iostream> 
#include <utility> 

template <class Function> 
class algo 
{ 
    double t; 
    Function fn; 

public: 
    algo(double t, const Function& fn) 
     : t{t}, fn{fn} 
    { } 
    double method(double x){ return t * fn(x);} 

}; 

template <class Function> 
algo<Function> make_algo(double t, Function&& fn) 
{ 
    return algo<Function>(t, std::forward<Function>(fn)); 
} 

int main() 
{ 
    const double someValue = 123; 
    const double anotherValue = 987; 

    auto algo = make_algo(anotherValue, [someValue](double otherValue) { 
     return someValue * otherValue; 
    }); 

    std::cout << std::fixed << algo.method(321) << std::endl; 
}