Wie gehen Sie mit immer längeren Kompilierzeiten beim Arbeiten mit Vorlagen um?

Ich benutze Visual Studio 2012 und er hat Fälle, in denen wir einer Klasse "nur" Vorlagenparameter hinzugefügt haben, um einen "Nahtpunkt" einzufügen, damit wir diese Teile im Komponententest durch Scheinobjekte ersetzen können.

Wie führen Sie in C ++ normalerweise Nahtpunkte ein: Verwenden von Schnittstellen und / oder Mischen basierend auf einigen Kriterien mit impliziten Schnittstellen, indem Sie auch Vorlagenparameter verwenden? Ein Grund, dies zu erfragen, liegt auch darin, dass beim Kompilieren einer einzelnen C ++ - Datei (die Vorlagendateien enthält, die auch andere Vorlagen enthalten können) eine Objektdatei generiert wird, die auf einem Entwicklercomputer in der Größenordnung von etwa 5 bis 10 Sekunden dauert .

Der VS-Compiler ist meines Wissens auch nicht besonders schnell beim Kompilieren von Vorlagen und aufgrund des Vorlageneinschlussmodells (Sie fügen praktisch die Definition der Vorlage in jede Datei ein, die sie indirekt verwendet, und instanziieren diese Vorlage möglicherweise bei jeder Änderung neu Etwas, das nichts mit dieser Vorlage zu tun hat. Sie könnten Probleme mit den Kompilierzeiten haben (beim inkrementellen Kompilieren).

Wie gehen Sie mit der inkrementellen (und nicht nur) Kompilierzeit beim Arbeiten mit Vorlagen um (neben einem besseren / schnelleren Compiler :-))?

Wenn Ihre Vorlagenparameter nur einen begrenzten (und kleinen) Wertesatz annehmen können, können Sie deren Definition in eine Quelldatei verschieben und eine explizite Instanziierung verwenden .

Zum Beispiel aaa.hdeklarieren Sie in nur die Template-Funktionen fund g:

template <int n>
int f();

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

Es sei angenommen , nTemplate - Parameter nur 1 sein kann, 3, 6 und TTemplate - Parameter können nur sein int, longund void *.

Dann definieren Sie sie aaa.cppwie folgt:

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);

Auf diese Weise instanziiert der Compiler beim Kompilieren die Vorlage für die angegebenen Parameter aaa.cpp. Beim Kompilieren von Client-Code wird davon ausgegangen, dass die Definitionen irgendwo existieren, und der Linker wird sich darum kümmern.

#include "aaa.h"

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

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

Sie können Vorlagenklassen auch explizit instanziieren. Der Nachteil ist, dass Sie nicht foder gmit anderen Template-Parametern arbeiten können.

#include "aaa.h"

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

Ergebnisse in

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

Ich habe diese Technik in einem Projekt verwendet, in dem nur wenige komplexe Klassen von einem kleinen Satz (<10) von Ganzzahl-Vorlagenparametern abhängig waren und die Kompilierungszeit erheblich verkürzt wurde (da der Compiler die komplexen Vorlagendefinitionen beim Kompilieren des Client-Codes nicht analysieren musste). . Natürlich können je nach aktuellem Code kleinere Verbesserungen erzielt werden.

Einmal habe ich eine seltsame Lösung für ein ähnliches Problem verwendet: Das Einbeziehen der STL führte zu Kompilierzeiten von mehreren Sekunden pro Quelldatei - egal wie klein sie war. Also habe ich alle meine Quelldateien in eine Master-Datei aufgenommen und die Kompilierungszeit pro Datei hat sich kaum geändert ... was eine Steigerung um den Faktor 20+ bedeutete, da ich nur eine einzige Datei kompilieren musste.

Um das Design sauber zu halten, habe ich weiterhin ein Makefile gepflegt, es aber nie verwendet (außer, dass überprüft wurde, ob es noch funktioniert).

Früher haben wir eine große Aufgabe ausgelöst, um unsere vorkompilierten Header und vorkompilierten Vorlagen über Nacht zu erstellen und erst am nächsten Tag gegen diese zu arbeiten.