看起来我有一个更长的表达式(展开的循环)，例如下面的代码在一个软件中多次膨胀了数千行。

由于 poly 为性能采用模板参数(第二个参数对应于循环 z 值)，我想知道是否可以通过模板元编程简化下面的代码并通过递归构建类似于循环的东西。表达式的语法似乎是每个 x = bx (a + b + c * by * bz) + ..

我想，如果 poly 不是模板函数，而是采用函数参数，那会更容易一些。

void calc(float mat[3][3][3], float fS, float fT, float fU)
{
    const float bs20_u = poly<2, 0>(fU);
    const float bs21_u = poly<2, 1>(fU);
    const float bs22_u = poly<2, 2>(fU);

    const float bs20_s = poly<2, 0>(fS);
    const float bs21_s = poly<2, 1>(fS);
    const float bs22_s = poly<2, 2>(fS);

    const float bs20_t = poly<2, 0>(fT);
    const float bs21_t = poly<2, 1>(fT);
    const float bs22_t = poly<2, 2>(fT);

    float result = 
       ((mat[0][0][0] * bs20_u + mat[0][0][1] * bs21_u + mat[0][0][2] * bs22_u) * bs20_t
      + (mat[0][1][0] * bs20_u + mat[0][1][1] * bs21_u + mat[0][1][2] * bs22_u) * bs21_t
      + (mat[0][2][0] * bs20_u + mat[0][2][1] * bs21_u + mat[0][2][2] * bs22_u) * bs22_t)
      * bs20_s
      +
       ((mat[1][0][0] * bs20_u + mat[1][0][1] * bs21_u + mat[1][0][2] * bs22_u) * bs20_t
      + (mat[1][1][0] * bs20_u + mat[1][1][1] * bs21_u + mat[1][1][2] * bs22_u) * bs21_t
      + (mat[1][2][0] * bs20_u + mat[1][2][1] * bs21_u + mat[1][2][2] * bs22_u) * bs22_t)
      * bs21_s
      +
       ((mat[2][0][0] * bs20_u + mat[2][0][1] * bs21_u + mat[2][0][2] * bs22_u) * bs20_t
      + (mat[2][1][0] * bs20_u + mat[2][1][1] * bs21_u + mat[2][1][2] * bs22_u) * bs21_t
      + (mat[2][2][0] * bs20_u + mat[2][2][1] * bs21_u + mat[2][2][2] * bs22_u) * bs22_t)
      * bs22_s;
}

最佳答案

template<std::size_t...Is>
auto index_over(std::index_sequence<Is...>) {
  return [](auto&& f)->decltype(auto){
    return decltype(f)(f)( std::integral_constant< std::size_t, Is >{}... );
  };
}
template<std::size_t N>
auto index_upto(std::integral_constant<std::size_t, N> ={}) {
  return index_over( std::make_index_sequence<N>{} );
}
inline float sum() { return 0.0f; }
template<class...Args>
float sum( float a, Args... args ) {
  return a + sum(args...);
}

我认为应该这样做。

auto Z_f = [&](auto X, auto Y)->float {
  return index_upto<2>()( [&](auto...Zs)->float{
    return sum((poly<2,Zs>(fU) * mat[X][Y][Zs])...);
  });
};
auto Y_f = [&](auto X)->float {
  return index_upto<2>()( [&](auto...Ys)->float{
    return sum( (poly<2,Ys>(fT) * Z_f(X, Ys))... );
  });
};
auto X_f = [&]()->float {
  return index_upto<2>()( [&](auto...Xs)->float{
    return sum( (poly<2,Xs>(fS) * Y_f(Xs))... );
  });
};

float val = X_f();

不确定这是否更简洁，但也许通过更多的工作我们可以将 X_f、Y_f 和 Z_f 重构为一个函数.

clang 能够通过不断输入恒定值来优化这一点。

这使用了一些 C++14 结构(index_sequence 和 make_index_sequence)，可以很容易地在 C++11 中重新实现。

我使用 auto 参数来制作模板 lambda，同样是 C++14。在 C++11 中执行此操作需要您手动编写所述 lambda，这很痛苦。

sum 在 C++17 中可以写成 (0.f + ... + args)。

Live example显示它正在运行。

godbolt显示它会编译成一个常量。

如果您不需要保留操作的确切顺序，并且愿意进行更多的乘法运算，我们可以生成一个案例，我们得到所有 3 个 X、Y 和 Z，然后调用一个目标编译时常量并将结果相加。

auto contribution = [&](auto X, auto Y, auto Z) {
  return mat[X][Y][Z] * poly<2,X>(fS) * poly2<2,Y>(fT) * poly2<2,Z>(fU);
};

但我在一行中执行此操作时遇到问题，因为您最终会得到 3 个要单独扩展的事件包。

auto summer_1d = [](auto...Vals)->decltype(auto){
  return sum(Vals...);
};
template<std::size_t X_max, std::size_t Y_max, std::size_t Z_max, class Sum = decltype(summer_1d)>
auto sumup_3d(Sum sum = summer_1d) {
  return [](auto&& f)->decltype(auto) {
    auto Z_part = [&](auto X, auto Y)->decltype(auto) {
      return index_upto<Z_max>()([&](auto...Zs)->decltype(auto){
        return sum( f(X,Y,Zs)... );
      });
    };
    auto Y_part = [&](auto X)->decltype(auto) {
      return index_upto<Y_max>()([&](auto...Ys)->decltype(auto){
        return sum( Z_part(X, Ys)... );
      });
    };
    return index_upto<X_max>()([&](auto...Xs)->decltype(auto){
      return sum( Y_part(Xs)... );
    });
  };
};

auto val = sumup_3d<3,3,3>()(contribution);

或类似的东西。

关于c++ - 使用 constexpr 或模板元编程简化较长的展开循环表达式，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45036994/