Question

Consider the following simple function

void foo_rt(int n) {
    for(int i=0; i<n; ++i) {
        // ... do something relatively cheap ...
    }
}

If I know the parameter n at compiletime, I can write a template version of the same function:

template<int n>
void foo_ct() {
    for(int i=0; i<n; ++i) {
        // ... do something relatively cheap ...
    }
}

This allows the compiler to do things like loop unrolling, which increases speed.

But assume now that I sometimes know n at compiletime and sometimes only at runtime. How can I implement this without maintaining two versions of the function? I was thinking something along the lines:

inline void foo(int n) {
    for(int i=0; i<n; ++i) {
        // ... do something relatively cheap ...
    }
}

// Runtime version
void foo_rt(int n) { foo(n); }

// Compiletime version
template<int n>
void foo_ct() { foo(n); }

But I am not sure if all compilers are smart enough to deal with this. Is there a better way?

EDIT:

Clearly, one solution that will work is to use macros, but this I really want to avoid:

#define foo_body \
{ \
    for(int i=0; i<n; ++i) { \
        // ... do something relatively cheap ... \
    } \
}

// Runtime version
void foo_rt(int n) foo_body

// Compiletime version
template<int n>
void foo_ct() foo_body

Answer 1

I’ve done this before, using a integral_variable type and std::integral_constant. This looks like a lot of code, but if you look again, it’s actually only a series of four very simple pieces, one of which is merely demo code.

#include <type_traits>

//type for acting like integeral_constant but with a variable
template<class underlying>
struct integral_variable {
    const underlying value;
    integral_variable(underlying v) :value(v) {}
}; 

//generic function
template<class value> 
void foo(value n) {
    for(int i=0; i<n.value; ++i) {
        // ... do something relatively cheap ...
    }
} 

//optional: specialize so callers don't have to do casts
void foo_rt(int n) { return foo(integral_variable<int>(n)); }
template<int n>
void foo_ct() { return foo(std::integral_constant<unsigned, n>()); }
//notice it even handles different underlying types.  Doesn't care.

//usage is simple
int main() {
    foo_rt(3);
    foo_ct<17>();
}