C++模板递归停止条件

Question

假设我的代码：

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

应该创建的num巢级别嵌套循环。当我尝试编译它时，我得到编译器有关过深递归的错误，即似乎编译器不会消除if（0> 0）语句。

有没有一种好的方法来实现这一点，而不必为num=0创建单独的专业化？

Answer 1

有一种方法，安德烈Alexandrescu的已提出在他的一个讲座，在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); 
    } 
} 

这是指actLoop如果num是0同一实例，因此打破了无限的实例。

Answer 2

if(num > 0)是一个运行时间条件。递归发生在编译时。所以不，没有办法避免num = 0的专业化。

为什么它是一个问题，但要创建num = 0的专业化？

Answer 3

不阻止全内联与最终的递归调用的方法是：

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

，我们呼吁-1情况下比在其他情况下，不同的过载。

另一种方法是将函数调用反弹到template class，在那里你专注于num = -1的情况。

Answer 4

这里最明显的迹象是num。你不需要描述的nonce名称与你无法描述的混淆名称是有区别的。你试图让num表示两种不同的东西，剩余的循环层数和你用于簿记的数组索引。

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