Question

I have a template function which accepts a function-object (‘functor’) as a template parameter:

 template <typename Func> int f (void) {
    Func func;
    return func ();
};

struct Functor {
   virtual int operator () (void) = 0;
};

struct Functor0 : Functor {
    int operator () (void) {
        return 0;
    }
};

struct Functor1 : Functor  {
    int operator ()  (void) {
        return 1;
    }
};

I want to avoid an if-else block like:

int a;
if (someCondition) {
    a = f<Functor0> ();
}
else {
    a = f<Functor1> ();
}

Is there a way to use something similar to dynamic binding, i.e something like:

a = f<Functor> (); // I know this line won't compile, it is just an example of what I need

and decide in runtime what (derived) type is passed as the template parameter?

Answer 1

Is there a way to use something similar to dynamic binding

No. This is fundamentally impossible. At some point in your code you need to have the case distinction. Of course, that doesn’t have to be written manually; you can use macros (or again templates) to generate the necessary code. But it needs to be there.