¿Hay algún recurso sobre cómo identificar los problemas que podrían resolverse mejor con plantillas?

Decidí mejorar mis conocimientos en metaprogramación de plantillas. Conozco la sintaxis y las reglas, y he estado jugando con innumerables ejemplos de recursos en línea.

Entiendo cuán poderosas pueden ser las plantillas y cuánta optimización del tiempo de compilación pueden proporcionar, pero todavía no puedo "pensar en plantillas", parece que no puedo saber por mí mismo si un cierto problema podría resolverse mejor con plantillas y si puede, cómo adaptar ese problema a las plantillas.

¿Existe algún tipo de recurso o libro en línea que enseñe cómo identificar problemas que podrían resolverse mejor con plantillas y cómo adaptar ese problema?

Libros:

Diseño moderno de C ++

Metaprogramación de plantilla C ++

Estar familiarizado con la recursividad y la programación funcional es una gran ventaja, ya que eso es lo que implica mucha tmp. Se está completando y, por lo tanto, esencialmente todo es posible, aunque generalmente se reduce a aplicar funciones puras a constantes o generar tipos de otros tipos.

Advertencia: tmp es un monstruo feo que convierte un buen código en espagueti. Cuanto más lo use, menos le gustará C ++. Es una cosa malvada.

Aprenda Haskell o algún otro lenguaje funcional puro (Lisp, Scheme, OCaml, por nombrar algunos, puede encontrar más en Wikipedia ).

Teniendo en cuenta Haskell, puede encontrar más información sobre sus instalaciones de metaprogramación aquí .

La programación de plantillas sigue las mismas reglas en realidad.

El hecho de que pueda hacer algo con las plantillas no significa que deba hacerlo. En términos prácticos, a menos que cuando esté diseñando piense que este es un trabajo increíble para las plantillas, probablemente sea mejor no usarlas. Si piensas demasiado en las plantillas, solo creas un código increíblemente abstracto que es tan malo como una sola función gigante.

Tenga en cuenta que las plantillas son la mejor solución es muy raro. Solo he definido el mío una vez en los últimos 5 años, y mis colegas que revisaron ese código nunca lo habían hecho. Los casos en los que las plantillas tienen mucho sentido ya se han implementado en su mayoría en bibliotecas estándar.

Para la programación genérica, lo que debe tener en cuenta es que está copiando y pegando funciones para realizar solo cambios menores, como en constantes o tipos, y no puede encontrar una forma limpia de usar algo como la herencia o los parámetros de función para evitar repetir tú mismo.

Una forma bastante común de usar plantillas es para la seguridad de tipos, si tiene tipos que se comportan igual, pero por cualquier razón no desea que se mezclen accidentalmente.

Para el cálculo del tiempo de compilación usando plantillas, lo que hay que tener en cuenta son los cálculos intensivos en recursos donde todas sus entradas son conocidas en el momento de la compilación, pero donde se usan diferentes entradas constantes en diferentes lugares a lo largo del código. Sin embargo, tenga en cuenta que esto ralentizará sus compilaciones cada vez, por lo que a menudo es preferible codificar los resultados de forma manual, si no cambian con mucha frecuencia.

Algunos defensores usan plantillas para microoptimizaciones, como evitar búsquedas de tablas virtuales con polimorfismo estático o para desenrollar bucles, pero en mi opinión, la complejidad generalmente supera las ganancias de rendimiento a menos que su código sea muy crítico para el rendimiento.

Básicamente, hay varias buenas razones para usar plantillas:

1. Tiene una función o una clase que tiene la misma funcionalidad para diferentes tipos. Un buen ejemplo de buen uso de plantillas es la biblioteca boost
2. desea utilizar el polimorfismo estático y obtener errores de compilación, en lugar de errores de tiempo de ejecución
3. Desea obtener un comportamiento específico dependiendo de algunos parámetros estáticos. Por ejemplo, boost :: type_traits proporciona muy buenos ejemplos.

¡Definitivamente deberías buscar plantillas en C ++! Esto lo ayudará en gran medida a comprender temas como Patrones de diseño y Programación genérica. Compárelos con lo que otros idiomas le ofrecen. En concreto, debe usar plantillas particularmente en los siguientes escenarios:

1. Generalización y reutilización de código
2. Flexibilidad
3. Restricciones de tiempo y presupuesto
4. Falta de experiencia para una determinada tarea.

Aquí hay un buen recurso en línea para usted: http://en.wikipedia.org/wiki/Generic_programming#Templates_in_C.2B.2B

Un indicador simple de cuándo una plantilla mejoraría su código, es cuando ve que su código con frecuencia requiere que eche un objeto a un tipo diferente. Un ejemplo que encontré en mi propio código Java, que me activó para convertir una firma de método existente en una plantilla:

    public MsgBase getLastSentMessage(Class<? extends MsgBase> msgBaseClass)

Mi código de cliente siempre se veía así:

    OrderResponse response = (OrderResponse) getLastSentMessage(OrderResponse.class);

y cada vez que usaba ese método, tenía que convertir el resultado a la subclase correcta del tipo MsgBase. La firma del método mejorado fue:

    public <T extends MsgBase> T getLastSentMessage(Class<T> clazz)

Ahora el código del cliente era:

     OrderResponse response = getLastSentMessage(OrderResponse.class);

Para resumir, si te encuentras haciendo una gran cantidad de casting que parece innecesario, puedes tener un buen caso en el que una plantilla limpiará tu código.

Actualización: una mejor manera de generalizar la declaración anterior:

Cuando su clase fuente será utilizada por objetos de muchos tipos diferentes, y la clase fuente puede interactuar con esos tipos en un nivel más alto (más abstracto), pero sus clases cliente quieren interactuar con subtipos específicos, ese es un caso para usar plantillas . (Las clases Contenedor / Lista son el ejemplo bien conocido).

Justo hoy, utilicé plantillas para implementar una máquina de estados finitos para obtener algunas entradas. Las plantillas de expresión son herramientas extremadamente poderosas para implementar conceptos de código como ese: se ejecutan como C ++ optimizado a mano y son obscenamente rápidas, pero muy genéricas y muy fáciles de escribir.

En términos generales, las plantillas tienen más sentido al implementar algoritmos genéricos. Si no está implementando un algoritmo genérico, no tienen mucho sentido.

Los usos más comunes de las plantillas son los siguientes:

std::vector<int> vec;
std::map<int, float> mymap;

Entonces el siguiente ejemplo común es:

template<class T>
class MyArray {
public:
   virtual T get(int i) const=0;
};

Junto con este tipo de uso:

class ArrayImpl : public MyArray<float> {
public:
     float get(int i) const { }
};

Ese mostró una parte importante de las plantillas, que es la sustitución de tipos: T se reemplaza por tipo flotante en ambos lugares donde se usa.