可變模板循環，非遞歸

Question

我有一些功能，可以執行復雜的繪圖。 [偽代碼]

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(field : fields)。

---

我找到了這個可變參數模板循環實現，但它是遞歸的。 對於性能響應，這甚至比 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] 上的結果？ 如果是，比如何？

Answer 1

我認為這樣做沒有任何意義。 編譯器應該將 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>();
}