C++模板递归停止条件

Question

Suppose I have the code:

template<size_t num> void actLoop(float* result, const float* rvector,
                                          size_t* xs, size_t indexIn=0)
{
    for(xs[num]=0; xs[num]<N; ++xs[num])
    {
        size_t index = indexIn+xs[num]*strides[num];
        if(num>0)
            actLoop<num-1>(result,rvector,xs,index);
        else
            result[index] = work(rvector,index,xs);
    }
}

It should create nested loop with nest level of num . When I try to compile it, I get compiler error about too deep recursion, ie seems compiler doesn't eliminate if(0>0) statement.

Is there a good way to make this happen, not having to create separate specialization for num=0 ?

Answer 1

The if( num > 0 ) is a runtime condition. The recursion is happening at compile time. So no, there is no way to avoid the specialization for num = 0 .

Why is it a problem though, to create the specialization for num = 0 ?

Answer 2

There's a way, Andrei Alexandrescu has presented it in one of his talks at Going Native 2013 :

template<size_t num> void actLoop(float* result, const float* rvector,
                                          size_t* xs, size_t indexIn=0)
{
    for(xs[num]=0; xs[num]<N; ++xs[num])
    {
        size_t index = indexIn+xs[num]*strides[num];
        if(num>0)
            actLoop<(num > 0 ? num-1 : num)>(result,rvector,xs,index);
        else
            result[index] = work(rvector,index,xs);
    }
}

This refers to the same instantiation of actLoop if num is 0 , therefore breaking the infinite instantiation.

Answer 3

The clearest indication that something's wrong here is num . There's a difference between nonce names you don't need to describe and confused names you can't. You're trying to make num mean two different things, the number of loop layers remaining and the array index you're using for bookkeeping.

template<size_t nloops>
void actLoop(float* result, const float* rvector, size_t* xs, size_t index=0)
{       // loop layers (nloops>=1): loop
        auto xs_index=nloops-1;
        for ( int i=0 ; i < N ; ++i ) {
                xs[xs_index] = i;
                actLoop<nloops-1>(result, rvector, xs, index + i*strides[xs_index]);
        }
}

template<>
void actLoop<0>(float* result, const float* rvector, size_t* xs, size_t index)
{       // no loops left: work
                result[index] = work(rvector,index,xs);
}

Answer 4

A way that doesn't block full inlining with a final recursive call is:

template<size_t num> void actLoop(float* result, const float* rvector,
                                      size_t* xs, size_t indexIn=0, std::false_type )
{
  result[index] = work(rvector,index,xs);
}

template<size_t num> void actLoop(
    float* result,
    const float* rvector,
    size_t* xs,
    size_t indexIn=0,
    std::true_type unused=std::true_type()
  )
{
  for(xs[num]=0; xs[num]<N; ++xs[num])
  {
    size_t index = indexIn+xs[num]*strides[num];
    actLoop<num-1>(result, rvector, xs, index, typename std::conditional<(num>0), std::true_type, std::false_type>::type());
   }
}

where we call a different overload on the -1 case than on the other cases.

Another approach would be to bounce the function call to a template class , where you specialize around the num = -1 case.

Answer 5

With modern C++ (since C++17) this problem can be solved much more straightforwardly: by using if constexpr statement. Here's the modified version of the code in the OP (with some dummy wrapper to make it compilable):

#include <stddef.h>

float work(const float*,size_t,const size_t*) { return 0; }
const unsigned N=5;
size_t strides[10];

template<size_t num> void actLoop(float* result, const float* rvector,
                                          size_t* xs, size_t indexIn=0)
{
    for(xs[num]=0; xs[num]<N; ++xs[num])
    {
        size_t index = indexIn+xs[num]*strides[num];
        if constexpr(num>0)
            actLoop<num-1>(result,rvector,xs,index);
        else
            result[index] = work(rvector,index,xs);
    }
}

int main()
{
    float res[10], rvec[10]={};
    size_t xs[10], str[10]={};
    actLoop<5>(res,rvec,xs);
}