Come gestite tempi di compilazione sempre più lunghi quando lavorate con i template?

Uso Visual Studio 2012 e ha casi in cui abbiamo aggiunto i parametri dei modelli a una classe "solo" per introdurre un "punto di giuntura" in modo che nel test unitario possiamo sostituire quelle parti con oggetti finti.

Come si introducono solitamente i punti di cucitura in C ++: utilizzando le interfacce e / o il missaggio basato su alcuni criteri con interfacce implicite usando anche i parametri dei template? Un motivo per chiederlo è anche perché durante la compilazione a volte di un singolo file C ++ (che include file di modelli, che potrebbero includere anche altri modelli), viene generato un file oggetto che richiede circa 5-10 secondi su una macchina dello sviluppatore .

Anche il compilatore VS non è particolarmente veloce nella compilazione di modelli per quanto ne so, e a causa del modello di inclusione dei modelli (praticamente includi la definizione del modello in ogni file che lo utilizza indirettamente e possibilmente ri-istanziare quel modello ogni volta che modifichi qualcosa che non ha nulla a che fare con quel modello) potresti avere problemi con i tempi di compilazione (quando si esegue la compilazione incrementale).

Quali sono i tuoi modi di gestire il tempo di compilazione incrementale (e non solo) quando lavori con i template (oltre a un compilatore migliore / più veloce :-)).

Se i parametri dei modelli possono assumere solo un insieme finito (e piccolo) di valori, è possibile spostare la loro definizione in un file di origine e utilizzare un'istanza esplicita .

Ad esempio, in aaa.hte dichiari solo le funzioni del modello fe g:

template <int n>
int f();

template <class T>
void g(int a);

Si supponga nmodello di parametro può essere solo 1, 3, 6, e Tparametro di modello può essere solo int, longe void *.

Quindi li definisci in aaa.cppquesto modo:

template <int n>
int f()
{
    ...
}

template <class T>
void g(int a)
{
    ...
}

template int f<1>();
template int f<3>();
template int f<6>();

template void g<int>(int a);
template void g<long>(int a);
template void g<void *>(int a);

In questo modo il compilatore crea un'istanza del modello per i parametri dati durante la compilazione aaa.cpp. Quando si compila il codice client, si presume che le definizioni esistano da qualche parte e che il linker se ne occuperà.

#include "aaa.h"

int main()
{
    f<1>();
    f<3>();
    f<6>();

    g<int>(5);
    g<long>(5);
    g<void *>(5);
}

Puoi anche istanziare esplicitamente le classi di template. Lo svantaggio è che non è possibile utilizzare fo gcon altri parametri del modello.

#include "aaa.h"

int main()
{
    f<5>();
}

risultati in

undefined reference to `int f<5>()'

Ho usato questa tecnica in un progetto in cui poche classi complesse dipendevano da un piccolo (<10) set di parametri del modello intero e ha ridotto significativamente i tempi di compilazione (poiché il compilatore non ha dovuto analizzare le definizioni complesse del modello durante la compilazione del codice client) . Ovviamente potresti ottenere miglioramenti minori, a seconda del codice effettivo.

Una volta ho usato una strana soluzione per un problema simile: Includere il comando STL per compilare tempi come diversi secondi per file di origine - non importa quanto fosse piccolo. Quindi ho incluso tutti i miei file sorgente in un unico file master e il tempo di compilazione per file non è cambiato quasi mai ... il che significava una velocità del fattore 20+ poiché avevo solo un singolo file da compilare.

Per mantenere pulito il design ho continuato a mantenere un makefile, ma non l'ho mai effettivamente usato (tranne per la verifica che funzioni ancora).

Abbiamo usato per eseguire una grande attività per costruire le nostre intestazioni precompilate e modelli precompilati durante la notte, e costruire contro quelli il giorno seguente.