Estoy tratando de entender cómo aplicar la programación de plantillas (y, en algún momento futuro, la metaprogramación de plantillas) a escenarios del mundo real. Un problema que estoy encontrando es que las plantillas y el polimorfismo en C ++ no siempre juegan juntos como yo quiero.

Mi pregunta es si la forma en que estoy tratando de aplicar la programación de la plantilla es incorrecta (y debo usar OOP) o si todavía estoy atascado en la mentalidad de OOP.

En este caso particular, estoy tratando de resolver un problema usando el patrón de estrategia. Sigo corriendo en el problema donde termino queriendo que algo se comporte de forma polimórfica que las plantillas no parecen admitir.

Código OOP utilizando la composición:

class Interpolator {
   public:
     Interpolator(ICacheStrategy* const c, IDataSource* const d);
     Value GetValue(const double);
}

void main(...) {
    Interpolator* i;
    if(param==1)
       i = new Interpolator(new InMemoryStrategy(...), new TextFileDataSource(...));
    else if(param==2)
       i = new Interpolator(new InMemoryStrategy(...), new OdbcDataSource(...));
    else if(param==3)
       i = new Interpolator(new NoCachingStrategy(...), new RestDataSource(...));

    while(run) {
       double input = WaitForRequest();
       SendRequest( i->GetValue(input));
    }
}

Versión potencial de la plantilla:

class Interpolator<class TCacheStrategy, class TDataSource> {
   public:
     Interpolator();
     Value GetValue(const double);               //may not be the best way but
     void ConfigCache(const& ConfigObject);      //just to illustrate Cache/DS         
     void ConfigDataSource(const& ConfigObject); //need to configured

}

//Possible way of doing main?
void main(...) {
    if(param==1)
       DoIt(Interpolator<InMemoryStrategy,TextFileDataSource>(),c,d);
    else if(param==2)
       DoIt(Interpolator<InMemoryStrategy,OdbcDataSource>(),c,d)
    else if(param==3)
       DoIt(Interpolator<NoCachingStrategy,RestDataSource>(),c,d)

}

template<class T>
void DoIt(const T&  t, ConfigObject c, ConfigObject d) {
   t.ConfigCache(c);
   t.ConfigDataSource(c);
   while(run) {
      double input = WaitForRequest();
      SendRequest( t.GetValue(input));
   }
}

Cuando intento convertir la implementación de OOP en una implementación basada en plantillas, el código de Interpolator se puede traducir sin mucho dolor. Básicamente, reemplace las "interfaces" con los parámetros de tipo de plantilla y agregue un mecanismo para pasar una instancia de Strategy / DataSource o parámetros de configuración.

Pero cuando llego a la "principal", no me queda claro cómo se debe escribir para aprovechar las plantillas al estilo de la meta programación de plantillas. A menudo quiero usar el polimorfismo, pero parece que no funciona bien con las plantillas (a veces, siento que necesito los genéricos de Java de borrado de tipo ... ugh).

Cuando a menudo encuentro que quiero hacer es tener algo comoTemplateType<?,?> x = new TemplateType<X,Y>() donde a x no le importa lo que X, Y es.

De hecho, este es a menudo mi problema al usar plantillas.

¿Necesito aplicar un nivel más de plantillas?¿Estoy tratando de usar mi nueva y brillante llave de plantilla eléctrica para instalar un clavo OOP en una ranura PCI?¿O simplemente estoy pensando en todo esto mal cuando se trata de la programación de plantillas?

[Editar] Algunas personas han señalado que esto no es en realidad una metaprogramación de plantillas, por lo que he modificado la pregunta un poco. Tal vez eso sea parte del problema: todavía me he quejado de lo que realmente es TMP.