É necessária uma nova compilação toda vez que faço uma alteração no código?

4

Eu estou trabalhando em um projeto que tem cerca de cem arquivos diferentes (.cpp & .h), e requer cerca de uma hora para construir todo o projeto no MSVC 2008, suponha que eu agora faça uma alteração em qualquer arquivo, eu preciso construir o projeto inteiro mais uma vez, desde o começo, ou existe uma saída?

Eu sei que é muito, muito como noob, mas eu estou perdendo muito tempo, daí eu estava me perguntando

    
por potato man 18.06.2012 / 19:34
fonte

4 respostas

7

A resposta curta: Depende.

A resposta longa: Depende das dependências do seu código-fonte.

Por exemplo, se cada classe souber sobre todas as outras classes do projeto, toda vez que você fizer uma alteração em uma, provavelmente terá que recompilar a outra.

Também depende da ligação. Se você vincular tudo em um arquivo binário, é provável que ele compile tudo novamente. Uma maneira melhor seria separar as diferentes bibliotecas compartilhadas (DLLs) ou, no mínimo, arquivos separados de objetos (.o).

Mas então (no último caso) você pode precisar mexer nele para ver que ele não recompila todos os arquivos de objeto quando você só precisa recompilar um e vinculá-los todos juntos novamente.

Mas, novamente, talvez o processo de ligação demore um pouco também. Você basicamente precisa experimentar isso.

Em uma nota final ... Uma hora para criar ~ 100 arquivos ? É assim, caminho demais, a menos que você esteja rodando em uma máquina antiga realmente . Ou a menos que cada arquivo contenha dezenas de milhares de linhas.

    
por 18.06.2012 / 20:09
fonte
6

Existem dois tipos de compilações: clean compilações e incremental .

Uma compilação limpa sempre começa do zero: não é preciso nada além do projeto simples como entrada, descobre dependências e constrói todas as partes em ordem, montando-as na saída final. Uma compilação limpa, por definição, tem que recompilar todos os arquivos de origem em seu projeto; Ao fazer isso, ele produz arquivos intermediários, como .obj files, que não são binários de origem nem de envio - depois que a compilação é concluída, você pode descartá-los (que é o que o Build>Clean Solution deve fazer) ou pode deixá-los no lugar para mais tarde, o que nos leva a ...

Criações incrementais . Uma compilação incremental compara a data da última modificação de cada arquivo de origem com o registro de data e hora nos arquivos intermediários que produz, bem como com qualquer outra coisa que dependa dela ('targets'); Se alguma dependência tiver sido modificada após a última construção do destino, o destino será reconstruído, caso contrário, o arquivo da construção anterior será reutilizado. Por exemplo, se você tiver users.c , que é compilado em users.obj (um destino de compilação) e inclui users.h e basics.h (dependências), a compilação incremental verificará os registros de data e hora em todos esses arquivos e se qualquer um deles é mais recente que o de users.obj , então users.obj é reconstruído; caso contrário, o users.obj existente será considerado válido e essa etapa de criação específica poderá ser ignorada.

Como os builds incrementais apenas reconstroem o que precisa ser, eles normalmente são muito mais rápidos do que os builds limpos - para projetos grandes, mas bem estruturados, a diferença pode ser de apenas segundos vs. pausa para o almoço.

No entanto, a determinação correta das bordas de dependências em magia negra e algumas configurações globais invalidam todos os intermediários (por exemplo, se você alternar a arquitetura de destino), portanto, se você quiser "a coisa real", a maioria recomendará fazer uma compilação completa. Na verdade, praticamente todas as configurações de Integração Contínua (em que um servidor de compilação executa uma compilação completa a cada vez que um novo código é enviado ao repositório principal, totalmente automatizado) usam compilações limpas, simplesmente porque elas são a única maneira confiável de garantir que tudo esteja < em> realmente muito atualizado.

    
por 18.06.2012 / 23:01
fonte
1

Este é realmente o ponto de fazer. Apenas reconstrua o que você precisa para reconstruir, nada mais. Assim, seu makefile deve ser configurado de forma que os componentes construídos não fiquem em seu caminho enquanto você trabalha, como, por exemplo, despejá-los em um diretório de compilação. Ele também deve ter dependências adequadas configuradas, para que qualquer seção relevante do projeto seja recompilada se você alterar suas dependências.

Sugiro percorrer o makefile que você tem para o seu projeto e aprender o que todas as diferentes partes fazem. É outra ferramenta importante e útil. O manual não é muito longo e aborda tudo. Ou você pode ler Gerenciando projetos com o Gnu Make , que explica como o make é mais do que apenas um software compilador.

    
por 18.06.2012 / 20:39
fonte
1

Um 'make clean' só deve ser necessário uma vez se você acabou de começar a trabalhar em um projeto já existente, por exemplo acabou de ser baixado e descompactado, ou se você quer ter certeza de que tudo está atualizado, por exemplo para um lançamento. Se apenas alguns arquivos foram modificados, um simples 'make' deve ser suficiente. Cabe então ao utilitário 'make' encontrar e compilar apenas os arquivos modificados e vincular os resultados com os arquivos já compilados para criar o binário finalizado.

    
por 18.06.2012 / 21:36
fonte