O problema surge justamente na compilação separada (modularização), quando separamos a abstração* (a definição da função) da aplicação* (quando chamamos a função) em arquivos diferentes e tentamos compilar o código. Por exemplo:
arquivo.hpp:
arquivo.cpp:
Na hora em que tentarmos compilar esse código com um "g++ -c arquivo1.cpp" (você pode usar outros compiladores), o compilador indicará um erro, já que ele não pode saber (inferir) que tipo de variável utilizaremos ao chamarmos a função (obviamente, a função ainda não foi chamada).
* vide glossário.
Óh, e agora?! Quem poderá nos defender?!
Antes que você saia por aí batendo a cabeça nas paredes ou inserindo gambiarras no seu projeto, eis a solução para os seus problemas!!! :)
Antes de mais nada é bom manter uma coisa em mente: não é possível separarmos a abstração da aplicação quando usamos templates em C++. O que podemos fazer, então? Abordaremos nas próximas páginas 2 estratégias simples e mais usadas para resolver esse problema.
[2] Comentário enviado por an_drade em 05/03/2008 - 12:07h
Olá hbobenicio,
Na realidade, você não compila o Template e seu código, e sim o código que usa este. Isto pode parecer uma boa solução (na realidade, o é) mas tem um inconveniente muito ruim: se você usa este template em 10 lugares diferentes em seu código (sei lá, imagine 10 classes distintas), o código do template será compilado 10 vezes. Isso é péssimo para programas grandes, onde temos bem mais de 10 classes distintas (ou mesmo, pedaços de códigos espalhados por vários arquivos). É só tentar compilar o Firefox ou o KDE (se não me engano, os 2 usam muitas das classes STL).
Uma vez li em algum lugar que existe uma maneira de pré-compilar estes templates, um processo parecido com pré-compilação dos arquivos de cabeçalho, aumentando a velocidade total de compilação. Este processo gera um código intermediário otimizado que facilita a compilação dos códigos que a utilizam.
[3] Comentário enviado por hbobenicio em 05/03/2008 - 12:42h
an_drade,
é verdade, os templates só podem ser compilados se não forem separados do código que os chamam, não tem como fugir disso. Na verdade é assim que eles funcionam... o compilador descobre quais são os tipos que o seu código usa/precisa e gera a informação necessária.
Essas, como eu cito no artigo, são os métodos "mais fáceis" de se fazer tão "façanha". O que é feito é uma simulação dos padrões de modularização.
Condordo, quando o programa toma grande dimensões é desaconselhável que se use muito (ou mesmo algum) templates no seu código. É o famoso TRADE-OFF: templates podem ser "uma mão na roda" r diminuir muito trabalho, mas se o projeto ganha proporções muito
grandes, podemos ter problemas como os citados por você. Cabe a cada programador fazer sua escolha :D
abraços e obrigado pelo comentário. (pro humbhenri também).
[5] Comentário enviado por daniel.franca em 23/05/2008 - 13:19h
Bom o artigo.
Fiquei com uma duvida, vc cita o fato do código ficar visivel a quem for usa-lo pelo primeiro método. Porém no segundo metodo isso tb ocorre já que o codigo fonte (.cpp) não poderá estar compilado.
Vi q vc tratá bastante de C nos artigos, eu encontrei um tutorial de ponteiros na internet, o achei muito bom. Eu postei ele no meu blog, se quiser conferir está em: http://tecnosapiens.wordpress.com
Dicas de posts e comentários tb são bem vindos.