可变参数模板循环，非递归

Variadic template loop, non recursive

本文关键字：递归 循环 变参 参数      更新时间：2023-10-16

>我有一些函数，可以执行复杂的绘图。[伪代码]

template<typename fields...>       // field names of Brush class
void someFunction(){    
  for(very large loop){
     Brush brush = getBrush();
     int x;
     foreach(field : fields){     // <--- this somehow should be replaced
        x = brush.*field;
        brush.update(x);
     }
  }    
}

[清单 1]

我称之为：

someFunction<&Brush::xPos1, &Brush::xPos2, &Brush::xPos3, &Brush::xPos4>()

我希望编译器生成这样的东西：

void someFunction(){    
  for(very large loop){
     Brush brush = getBrush();
     int x;
        x = brush.xPos1;
        brush.update(x);
        x = brush.xPos2;
        brush.update(x);
        x = brush.xPos3;
        brush.update(x);
        x = brush.xPos4;
        brush.update(x);
  }    
}

[清单 2]

我的意思是，我想摆脱那个foreach（字段：字段）。

我发现了这个可变参数模板循环实现，但它是递归的。对于性能共鸣，这甚至比foreach循环更糟糕

int a;
template <class T>
void print(const T msg)
{
    a = msg;
}

// And this is the recursive case:
template <class A, class... B>
void print(A head, B... tail)
{
    a = head;
  print(head);
  print(tail...);
}

[清单 3]

所以问题是....是否有可能获得[清单2]上的结果？如果是，那么如何？

我认为这样做没有真正的意义。编译器应将 for 循环和递归模板优化为同一代码。无论如何，这样的事情应该有效：

struct Brush {
    int xPos1, xPos2, xPos3, xPos4;
    void update(int) {}
};
typedef int Brush::* Field;
template<Field...fs>
void Foo()
{
    Brush brush;
    int a[] = { (brush.update( brush.*fs ),0)... };
}
int main()
{
    Foo<&Brush::xPos1, &Brush::xPos2, &Brush::xPos3, &Brush::xPos4>();
}
相关文章：