Если цель здесь просто оптимизировать, а не разрешить использование в контексте времени компиляции, вы можете дать компилятору подсказки о своем намерении:

static float calcLength_inner(const float *v, int size, int inc) {
    float l = 0;

    for (int i=0; i<size*inc; i += inc) {
        l += v[i]*v[i];
    }
    return sqrt(l);
}

float calcLength(const float *v, int size, int inc) {
    if (inc == 1) {
        return calcLength_inner(v, size, inc);  // compiler knows inc == 1 here, and will optimize
    }
    else {
        return calcLength_inner(v, size, inc);
    }
}

Из godbolt вы можете видеть, что calcLength_inner был создан дважды, как с постоянным распространением, так и без него.

Это трюк C (и широко используется внутри numpy), но вы можете написать простую оболочку, чтобы упростить использование в C ++:

// give the compiler a hint that it can optimize `f` with knowledge of `cond`
template<typename Func>
auto optimize_for(bool cond, Func&& f) {
    if (cond) {
        return std::forward<Func>(f)();
    }
    else {
        return std::forward<Func>(f)();
    }
}

float calcLength(const float *v, int size, int inc) {
    return optimize_for(inc == 1, [&]{
        float l = 0;
        for (int i=0; i<size*inc; i += inc) {
            l += v[i]*v[i];
        }
        return sqrt(l);
    });
}

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

Если параметр должен быть параметром функции, и вы не желаете изменять способ его вызова в двух случаях, то единственный рычаг, который у вас есть, - это тип параметра: ваши предложения for Constant<1>() vs Var(inc) довольно хороши в этом отношении.

Вариант 1. Доверьтесь компилятору (или ничего не делайте)

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

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

Компилятор может полностью встроить эту функцию, потенциально делая вашу проблему не проблемой (вы можете помочь ей, указав ее встроенным в заголовок, используя lto и / или используя специфические атрибуты компилятора, такие как __attribute__((always_inline)))

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

Вариант 2: две перегрузки

float calcLength(const float *v, int size, int inc) {
    float l = 0;

    for (int i=0; i<size*inc; i += inc) {
        l += v[i]*v[i];
    }
    return sqrt(l);
}

template <int Inc>
float calcLength(const float *v, int size) {
    float l = 0;

    for (int i=0; i<size*inc; i += inc) {
        l += v[i]*v[i];
    }
    return sqrt(l);
}

Недостатком здесь является дублирование кода, ofc. Также необходимо проявлять небольшую осторожность на месте звонка:

calcLength(v, size, inc); // ok
calcLength<1>(v, size);   // ok
calcLength(v, size, 1);   // nope

Вариант 3: Ваша версия

Ваша версия в порядке.