Select at runtime to implement CRTP

I would like to use static polymorphism using the CRTP idiom, being able to choose at runtime which implementation to use. Let me give you an example:

I have several classes responsible for the computation:

template<typename Implementation>
class FooInterface {
public:
  void compute(){
    (static_cast<Implementation*>(this))->compute();
  }
};

class FooForward : public FooInterface<FooForward> {
public:
  void compute(){
    //do stuff
  }
};

class FooBackward : public FooInterface<FooBackward> {
public:
  void compute(){
    //do other stuff
  }
};

      

        
        
        
      

    

and

template<typename Implementation>
class BarInterface {
public:
  void eval(){
    (static_cast<Implementation*>(this))->eval();
  }
};

class BarForward : public BarInterface<BarForward> {
public:
  void eval(){
    //do something
  }
};

class BarBackward : public BarInterface<BarBackward> {
public:
  void eval(){
    //do something else
  }
};

      

        
        
        
      

    

Now I want to use these objects as members of another class, call it Model

and use them in a loop:

template<typename Foo, typename Bar>
class Model {
private:
  Foo* foo_;
  Bar* bar_;
  int max_iter_;

public:
  Model<Foo, Bar>(int max_iter) : max_iter_(max_iter){
    foo_ = new Foo();
    bar_ = new Bar();
  }

  void solve(){
    for(int i = 0; i < max_iter_; ++i){
      foo_->compute();
      bar_->eval();
    }
  }
};

      

        
        
        
      

    

Note that a function Model::solve()

is iterated over a lot and performance in my application is critical, so using CRTP instead of dynamic polymorphism to prevent virtual function calls and enable compiler nesting.

Now my problem arises when I want the user to decide which implementation FooInterface

and BarInterface

use at runtime. In mine main.cpp

I have:

int main(int argc, char** argv){
  /*
   * Here an input file is read into a map which looks like this
   * std::map<std::string, std::string> settings
   */
  // Here I need a way to choose, based on settings, what will Foo and Bar be
  Model<Foo, Bar> model;
  model.solve();
}

      

        
        
        
      

    

I thought of some kind of factory that could return the correct one Model

, but I don't know what the return type might be, and how I imagine it, it's not convenient, because in my application I have more than 2 template parameters, and then the number of combinations becomes very large

class Factory{
  /*type?*/ createModel(std::map<std::string, std::string> settings){
    if ((settings["foo"] == "fwd") && (settings["bar"] == "fwd")){
      Model<FooForward, BarForward>* model = new Model<FooForward, BarForward>();
      return model;
    }
    else if ((settings["foo"] == "fwd") && (settings["bar"] == "bwd")){
      Model<FooForward, BarBackward>* model = new Model<FooForward, BarBackward>();
      return model;
    }
    else if ((settings["foo"] == "bwd") && (settings["bar"] == "fwd")){
      Model<FooBackward, BarForward>* model = new Model<FooBackward, BarForward>();
      return model;
    }
    else {
      Model<FooBackward, BarBackward>* model = new Model<FooBackward, BarBackward>();
      return model;
    }
  }
};

      

        
        
        
      

    

As I imagine, all combinations of patterns will be compiled and the user can choose at runtime which one to use. Is there a way to accomplish this using CRTP?