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

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

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

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

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

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

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

Вариант 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);
}

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

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

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

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