Как вы справляетесь со все более длительным временем компиляции при работе с шаблонами?

Я использую Visual Studio 2012, и у него есть случаи, когда мы добавляли параметры шаблонов в класс «просто», чтобы ввести «точку шва», чтобы в модульном тесте мы могли заменить эти части на фиктивные объекты.

Как вы обычно вводите точки стыка в C ++: используя интерфейсы и / или смешивание на основе некоторых критериев с неявными интерфейсами, используя также параметры шаблонов? Одной из причин этого также является то, что при компиляции иногда одного файла C ++ (который включает файлы шаблонов, который может также включать другие шаблоны) получается генерируемый объектный файл, который занимает порядка 5-10 секунд на компьютере разработчика ,

Насколько я понимаю, VS-компилятор также не особенно быстро компилирует шаблоны и из-за модели включения шаблонов (вы фактически включаете определение шаблона в каждый файл, который использует его косвенно, и, возможно, создаете экземпляр этого шаблона каждый раз при изменении то, что не имеет ничего общего с этим шаблоном) могут возникнуть проблемы со временем компиляции (при выполнении инкрементной компиляции).

Каковы ваши способы обработки добавочного (и не только) времени компиляции при работе с шаблонами (помимо лучшего / более быстрого компилятора :-)).

Если параметры ваших шаблонов могут принимать только конечный (и небольшой) набор значений, вы можете переместить их определение в исходный файл и использовать явное создание экземпляров .

Например, в aaa.hвас только объявить функции шаблона fи g:

template <int n>
int f();

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

Предполагать n , шаблон параметр может быть только 1, 3, 6, и Tпараметр шаблона может быть только int, longи void *.

Затем вы определяете их aaa.cppследующим образом:

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

Таким образом, компилятор создает экземпляр шаблона для заданных параметров при компиляции. aaa.cpp . При компиляции клиентского кода предполагается, что определения где-то существуют, и компоновщик позаботится об этом.

#include "aaa.h"

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

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

Вы также можете явно создавать экземпляры шаблонных классов. Недостатком является то, что вы не можете использоватьf или gс другими параметрами шаблона.

#include "aaa.h"

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

результаты в

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

Я использовал эту технику в проекте, где несколько сложных классов зависели от небольшого (<10) набора целочисленных параметров шаблона, и это значительно сократило время компиляции (поскольку компилятору не приходилось анализировать определения сложных шаблонов при компиляции клиентского кода) , Конечно, вы можете получить меньшие улучшения, в зависимости от реального кода.

Однажды я использовал странное решение для аналогичной проблемы: включение STL приводит к времени компиляции, например, несколько секунд на исходный файл - независимо от того, насколько он крошечный. Поэтому я включил все мои исходные файлы в один мастер-файл, и время компиляции для каждого файла почти не изменилось ... что означало ускорение в 20 раз, так как у меня был только один файл для компиляции.

Чтобы сохранить дизайн в чистоте, я продолжал поддерживать make-файл, но никогда не использовал его (за исключением проверки, что он все еще работает).

Раньше мы выполняли большую задачу по созданию наших предварительно скомпилированных заголовков и предварительно скомпилированных шаблонов за одну ночь, и просто строили их на следующий день.