Sto lavorando su un progetto che ha circa un centinaio di file diversi (.cpp & .h), e richiede circa un'ora per costruire l'intero progetto su MSVC 2008, supponiamo che io ora apporti una modifica a qualcuno file, ho bisogno di ricostruire l'intero progetto ancora una volta, fin dall'inizio, o c'è una via d'uscita?
So che è molto molto simile a Noob, ma sto sprecando un sacco di tempo, quindi mi chiedevo
La risposta breve: dipende.
La risposta lunga: dipende dalle dipendenze del codice sorgente.
Ad esempio, se ogni classe sa di ogni altra classe nel progetto, allora ogni volta che apporti una modifica a una, probabilmente dovrai ricompilare l'altra.
Dipende anche dal collegamento. Se si collega tutto in un file binario, è anche probabile che compili tutto di nuovo. Un modo migliore sarebbe separare le diverse librerie condivise (DLL) o, per lo meno, in file separati (.o).
Ma poi (in quest'ultimo caso) potrebbe essere necessario armeggiare con esso per vedere che non ricompila tutti i file oggetto quando hai solo bisogno di ricompilarne uno e collegarli di nuovo tutti insieme.
Ma poi di nuovo, forse il processo di collegamento richiede troppo tempo. Fondamentalmente hai bisogno di sperimentarlo.
Una nota finale ... Un'ora per creare ~ 100 file ? È così, modo troppo, a meno che tu non stia correndo su una vecchia macchina veramente . O a meno che ogni file contenga decine di migliaia di linee.
Esistono due tipi di build: clean build e incremental .
Un clean build parte sempre da zero: non prende nient'altro che il semplice progetto come input, calcola le dipendenze e costruisce tutte le parti in ordine, quindi le assembla nell'output finale. Una build pulita, per definizione, deve ricompilare tutti i file sorgente nel progetto; mentre lo fa, produce file intermedi, come .obj file, che non sono né binari sorgente né binari shippabili - una volta che la compilazione è completa, puoi buttarli via (che è cosa dovrebbe fare Build>Clean Solution ), oppure tu possiamo lasciarli sul posto per dopo, il che ci porta a ...
Versioni incrementali . Una build incrementale confronta la data dell'ultima modifica del file sorgente con il timestamp sui file intermedi che produce, così come qualsiasi altra cosa che dipende da esso ('target'); se una dipendenza è stata modificata dopo la creazione dell'obiettivo, la destinazione viene ricostruita, altrimenti viene riutilizzato il file della build precedente. Ad esempio, se hai users.c , che viene compilato in users.obj (un target di compilazione) e include users.h e basics.h (dipendenze), la build incrementale controllerà i timestamp su tutti questi file e se nessuno di loro è più recente di quello su users.obj , quindi users.obj viene ricostruito; in caso contrario, il users.obj esistente è considerato valido e questo particolare passo di generazione può essere saltato.
Poiché le build incrementali ricostruiscono solo ciò che deve essere, in genere sono molto più veloci di quelle pulite: per progetti grandi ma ben strutturati, la differenza può essere solo di pochi secondi rispetto alla pausa pranzo.
Tuttavia, determinare correttamente le dipendenze confina con la magia nera e alcune impostazioni generali invalidano tutte le sostanze intermedie (ad es. se si cambia architettura di destinazione), quindi se si desidera "la cosa reale", la maggior parte delle persone consiglia di eseguire una compilazione completa. Infatti, praticamente tutte le configurazioni di Continuous Integration (dove un build server esegue una build completa ogni volta che il nuovo codice viene trasferito al master repository, completamente automatico) usano clean build, semplicemente perché sono l'unico modo affidabile per assicurarsi che tutto sia < em> veramente veramente aggiornato.
Questo è davvero il punto di arrivo. Ricostruisci solo ciò che devi ricostruire, niente di più. Pertanto, il makefile deve essere impostato in modo tale che i componenti creati non si intromettano mentre lavori, ad esempio scaricandoli in una directory di build. Dovrebbe anche essere configurato correttamente le dipendenze, in modo che eventuali sezioni rilevanti del progetto ricompilino se si cambiano le loro dipendenze.
Suggerisco di passare attraverso il makefile che hai per il tuo progetto e di imparare cosa fanno tutti i diversi pezzi. È un altro strumento importante e utile. Il manuale non è molto lungo e riguarda tutto. Oppure puoi leggere Gestire i progetti con Gnu Make , che spiega come make sia più di un semplice software compilatore.
Un "make clean" dovrebbe essere necessario una volta sola se hai appena iniziato a lavorare su un progetto già esistente, ad es. è stato appena scaricato e scompattato, oppure se vuoi essere sicuro che tutto sia aggiornato, ad es. per un rilascio. Se solo alcuni file sono stati modificati, un semplice "make" dovrebbe essere sufficiente. Spetta quindi all'utilità 'make' trovare e compilare solo i file modificati e collegare i risultati insieme ai file già compilati per creare il file binario finito.
Leggi altre domande sui tag development-process builds visual-studio