¿Las plantillas de C ++ son solo una especie de macros glorificadas?

De diferentes comparaciones entre plantillas C ++ y genéricos C # / Java como este:

/programming/31693/what-are-the-differences-between-generics-in-c-and-java-and-templates-in-c/31929#31929

Percibí que las plantillas de C ++ se implementan mediante algún tipo de preprocesamiento (reemplazo de texto sin formato antes del análisis), no compilando. Debido a que la comprobación de tipos en las plantillas de C ++ se parece a las macros de C. Quiero decir, si hay algunos errores, son errores del código generado después de procesar bloques de código con plantilla, no de las plantillas en sí. En otras palabras, son solo una especie de versión superior de macros en C.

Luego encontré algunos otros hechos que respaldan esto.

• Pensé que si las plantillas de C ++ se implementan mediante preprocesamiento, habrá problemas con la vinculación dinámica (usando .dll). Y una búsqueda rápida en Google lo apoyó.

• Otro punto es que las constantes enteras se pueden pasar como argumentos a las plantillas. E incluso admite algún tipo de recursión. Pero esta recursión no se encuentra en el ensamblado compilado / código de máquina. Lo de la recursividad se gestiona en tiempo de compilación al generar funciones para cada llamada recursiva y, por lo tanto, tener un binario ejecutable más grande pero más rápido.

Aunque a diferencia de las macros C, tiene algunas habilidades superiores. ¿Pero no se implementa la plantilla C ++ con algún tipo de preprocesamiento? ¿Cómo se implementa esto en diferentes compiladores de C ++?

Las plantillas de C ++ son una especie de macros tontas de Lisp (o incluso más, Scheme). Es un lenguaje completo de Turing que se evalúa en tiempo de compilación, pero está severamente limitado ya que no hay acceso desde ese lenguaje al entorno subyacente de C ++. Entonces, sí, las plantillas de C ++ pueden verse como alguna forma de preprocesamiento, con una interacción muy limitada con el código que se genera.

Probablemente la mayor diferencia es que las macros C se expanden en la fase de preprocesamiento, antes de que se realice cualquier otra compilación, mientras que las plantillas C ++ son parte de la compilación. Esto significa que las plantillas de C ++ son compatibles con el tipo y el alcance, entre otras cosas, y no son simples sustituciones textuales. Pueden compilar funciones reales y, por lo tanto, evitar la mayoría de los problemas que tienen las macros. Ser consciente de los tipos significa que pueden ser generales o especializados: por ejemplo, es fácil proporcionar una swapfunción de plantilla y escribir especializaciones que funcionen bien incluso si los objetos gestionan la memoria de almacenamiento dinámico.

Por lo tanto: las plantillas C ++ no están preprocesando en el mismo sentido que las macros, no son una especie de macro C y es imposible usar macros C para duplicar lo que hacen las plantillas.

Las plantillas viven en archivos de encabezado, no en bibliotecas vinculadas, es cierto, pero si está proporcionando un archivo .dll, presumiblemente también está proporcionando un archivo de encabezado para que lo use.

¿Importa cómo se implementan? Los primeros compiladores de C ++ eran solo preprocesadores que alimentaban el código al compilador ac, no significa que C ++ sea solo una macro glorificada.

Las plantillas eliminan la necesidad de macros al proporcionar una forma más segura, más eficiente y especializable (incluso no creo que sea una palabra real) de implementar código para múltiples tipos.

Hay una variedad de formas de hacer código de tipo de plantilla en c, ninguna de las cuales es muy buena una vez que va más allá de los tipos simples.

Hay algunas diferencias; por ejemplo, las plantillas se pueden usar para crear instancias de una sobrecarga de funciones cuando sea necesario, mientras que con las macros, tendrías que expandir la macro una vez por cada posible sobrecarga para que sea visible para el compilador, por lo que terminarías con muchas de código no utilizado.

Otra diferencia es que las plantillas respetan los espacios de nombres.

En mi humilde opinión, las plantillas C ++ y las macros C estaban destinadas a resolver dos problemas completamente diferentes. La Biblioteca de plantillas estándar de C ++ original era un mecanismo para desacoplar limpiamente las clases de contenedor (matrices, listas vinculadas, etc.) de las funciones genéricas que se les aplican comúnmente (como la ordenación y la concatenación). Tener representaciones abstractas de algoritmos eficientes y estructuras de datos conducen a un código más expresivo porque había significativamente menos conjeturas sobre la mejor manera de implementar una función que funcione en una determinada pieza de datos. Las macros de C estaban mucho más en línea con lo que normalmente se vería en las macros de Lisp, ya que proporcionaban un medio para "extender" el lenguaje con código en línea. Lo bueno es que la biblioteca estándar de C ++ extendió la funcionalidad de las plantillas para cubrir la gran mayoría de lo que usamos #define en C.