Os modelos C ++ são apenas um tipo de macros glorificadas?

De diferentes comparações entre modelos C ++ e genéricos C # / Java como este

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

Percebi que os modelos C ++ são implementados por algum tipo de pré-processamento (substituição de texto sem formatação antes da análise), não compilando. Porque a verificação de tipo nos modelos C ++ é semelhante às macros C. Quero dizer, se houver alguns erros, eles são erros do código gerado após o processamento de blocos de código modelados, não dos próprios modelos. Em outras palavras, eles são apenas um tipo de versão superior de macros em C.

Então eu encontrei alguns outros fatos que apóiam isso -

• Eu pensei que, se os modelos de C ++ forem implementados por pré-processamento, haverá problemas com o vínculo dinâmico (usando .dll). E uma pesquisa rápida apoiou isso.

• Outro ponto é que constantes inteiras podem ser passadas como argumentos para os modelos. E ainda suporta algum tipo de recursão. Mas essa recursão não é encontrada no código de montagem / máquina compilado. A coisa da recursão é gerenciada em tempo de compilação, gerando funções para cada chamada recursiva e, portanto, tendo um binário executável maior, mas mais rápido.

Embora diferente das macros C, ele possui algumas habilidades superiores. Mas o modelo C ++ não é implementado com algum tipo de pré-processamento? Como isso é implementado em diferentes compiladores C ++?

Modelos C ++ são uma espécie de macros Lisp (ou mais ainda, Scheme). É uma linguagem completa de Turing que avalia em tempo de compilação, mas é severamente limitada, pois não há acesso dessa linguagem ao ambiente C ++ subjacente. Portanto, sim, os modelos C ++ podem ser vistos como alguma forma de pré-processamento, com uma interação muito limitada com o código sendo gerado.

Provavelmente, a maior diferença é que as macros C são expandidas na fase de pré-processamento, antes de qualquer outra compilação, enquanto os modelos C ++ fazem parte da compilação. Isso significa que os modelos C ++ têm reconhecimento de tipo e escopo, entre outras coisas, e não são uma simples substituição de texto. Eles podem ser compilados para funções reais e, portanto, evitar a maioria dos problemas que as macros têm. Estar ciente do tipo significa que eles podem ser gerais ou especializados: por exemplo, é fácil fornecer uma swapfunção de modelo e escrever especializações que funcionam bem, mesmo que os objetos gerenciem a memória heap.

Portanto, os modelos C ++ não estão pré-processando no mesmo sentido que as macros, não são um tipo de macro C e é impossível usar macros C para duplicar o que os modelos fazem.

Os modelos vivem em arquivos de cabeçalho, não em bibliotecas vinculadas, é verdade, mas se você estiver fornecendo uma .dll, provavelmente também estará fornecendo um arquivo de cabeçalho para uso.

Importa como eles são implementados? Os primeiros compiladores C ++ eram apenas pré-processadores que alimentavam o código para o compilador CA, não significa que C ++ seja apenas uma macro glorificada.

Os modelos eliminam a necessidade de macros, fornecendo uma maneira mais segura, eficiente e especializada (mesmo que eu não ache que seja uma palavra real) de implementar código para vários tipos.

Existem várias maneiras de criar modelos de código de tipo em c, nenhum dos quais é muito bom quando você vai além dos tipos simples.

Existem algumas diferenças; por exemplo, os modelos podem ser usados ​​para instanciar uma sobrecarga de função quando necessário; enquanto nas macros, você precisa expandir a macro uma vez para cada sobrecarga possível, a fim de torná-la visível ao compilador, para acabar com muitas de código não utilizado.

Outra diferença é que os modelos respeitam os espaços para nome.

IMHO, modelos C ++ e macros C foram criados para resolver dois problemas completamente diferentes. A biblioteca de modelos padrão C ++ original era um mecanismo para separar de maneira limpa as classes de contêineres (matrizes, listas vinculadas etc.) das funções genéricas comumente aplicadas a elas (como classificação e concatenação). Ter representações abstratas de algoritmos e estruturas de dados eficientes leva a um código mais expressivo, porque havia significativamente menos suposições sobre a melhor forma de implementar uma função que trabalha em uma determinada peça de dados. As macros C estavam muito mais alinhadas com o que normalmente seria visto nas macros Lisp, na medida em que forneciam um meio de "estender" o idioma com código embutido. O legal é que a Biblioteca Padrão C ++ estendeu a funcionalidade dos modelos para cobrir a grande maioria do que usamos #define em C.