Что хорошего в использовании нетиповых параметров шаблона? [Дубликат]

Таким образом, я сомневаюсь (исправьте меня, если я ошибаюсь), что каждое другое значение размера приводит к созданию новых двоичных кодов (".text"), что, по-видимому, является накладными расходами.

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

Поскольку Мэтт уже привел простой пример, позволяет работать над функцией, которая принимает массив по ссылке:

template<typename T, size_t N>
size_t operateOnArray( T (&array)[N] )
{
     // Some complex logic, which could include:
    for (std::size_t i = 0; i < N; ++i) {
       // complicated stuff
    }
}

Тип аргумента является ссылкой на массив, компилятор проверяет для вас, что массив действительно имеет N элементов (и он будет выводить тип значений в массиве). Это отличное улучшение безопасности типов по сравнению с аналогичным кодом стиля C:

size_t operateOnArray( T *array, size_t N)
{
     // Some complex logic, which could include:
    for (std::size_t i = 0; i < N; ++i) {
       // complicated stuff
    }
}

В частности, пользователь может ошибочно передать неправильное значение:

int array[10];
operateOnArray(arrah, 20); // typo!!!

Где в первом случае компилятор выведет размер, и это будет гарантировать, что это правильно.

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

Есть решения вокруг этого, как смешивание двух подходов:

size_t operateOnArray( T *array, size_t N); // Possibly private, different name...
template<typename T, size_t N>
size_t operateOnArray( T (&array)[N] ) {
   operateOnArray(array, N);
}

В этом случае у компилятора будет одна единственная копия сложного кода в функции C-стиля и будет генерировать 100 версий шаблона, но они просты, достаточно просты, что компилятор будет встроить код и преобразовать программу в эквиваленте подхода C-стиля с гарантией безопасного типа.

Может ли кто-нибудь сказать, когда это необходимо и стоит?

Это необходимо, когда код внутри шаблона требует значения как константы времени компиляции, например, в приведенном выше коде, вы не можете иметь аргумент функции, который является ссылкой на массив из N элементов, где N доступен только во время выполнения. В других случаях, например std::array<T,N> требуется статически создавать массив соответствующего размера. Независимо от того, что, все примеры разделили это: значение должно быть известно во время компиляции.

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

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