C++ raczej statyczny niż dynamiczny polimorfizm

Question

Próbuję zbudować ogólny algorytm. Do tej pory udało mi się osiągnąć to za pomocą klasy hierarchii i wskazówek, jak w poniższym przykładzie:

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

}; 

Ten zestaw jest następnie realizowany w następujący sposób:

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

    return 0; 
} 

Jest to bardzo prosty przykład, oczywiście , ale służy do mojego pytania. Z tego co rozumiem, używanie klas pochodnych w ten sposób oznacza, że ​​metoda jest wybierana w czasie wykonywania, a nie w czasie kompilacji. Ponieważ nie potrzebuję żadnego dynamicznego zachowania z mojego algorytmu - wszystko jest ustalane w czasie kompilacji - jest to niepotrzebna utrata wydajności. Czy istnieje sposób na wykonanie powyższych czynności w czasie kompilacji, czyli statyczny polimorfizm?

Z tego co rozumiem, można uzyskać statyczny polimorfizm za pomocą szablonów. Nie udało mi się jednak znaleźć szablonów narzędzi z typami nieprostymi. Jak w powyższym przykładzie, potrzebuję klas pochodnych z nie-domyślnymi konstruktorami, co nie wydaje się możliwe ... Czy ktokolwiek mógłby zaproponować rozwiązania, jak to zrobić?

Answer 1

klasy bazowej i pochodne wydają się reprezentować funkcję tylko o jedną funkcję Członka, więc mogliśmy najprawdopodobniej rezygnacji z polimorfizmem całkowicie i przekazać funkcję w 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; 
}