带模板的 N 维嵌套金属循环

我正在尝试使用模板元编程进行 N 维嵌套金属循环。 嵌套部分很简单，但是将所有任意数量的迭代索引作为模板参数传递到最内层循环似乎有问题。

一个简单的未嵌套的金属环看起来像：

template <size_t I, size_t N>
struct meta_for
{
    template <typename Lambda>
    inline meta_for(Lambda &&iteration)
    {
        iteration(I);
        meta_for<I+1, N> next(static_cast<Lambda&&>(iteration));
    }
};

template <size_t N>
struct meta_for<N, N>
{
    template <typename Lambda>
    inline meta_for(Lambda &&iteration)
    {
        return;
    }
};

#include <iostream>

int main()
{
    meta_for<0, 10>([&](size_t i) // perform 10 iterations
    {
        std::cout << i << '\n';
    });

    return 0;
}

现在，我想制作一个metaloop，它接受一个表示维度（嵌套级别）的 N 参数，使用如下：

#include <iostream>

int main()
{
    // perform 3 dimensionally nested iterations
    // each index goes from 0 to 10
    // so 10x10x10 iterations performed
    meta_for<3, 0, 10>([&](size_t i, size_t j, size_t k)
    {
        std::cout << i << ' ' << j << ' ' << k << '\n';
    });

    return 0;
}

由于这个问题似乎仍然很受欢迎，我认为最好展示一下在 C++17 中这样做是多么容易。一、完整代码

Demo https://wandbox.org/permlink/YVU8ehBqck6a0K8m

template<size_t Dimensions, class Callable>
constexpr void meta_for_loop(size_t begin, size_t end, Callable&& c)
{
    static_assert(Dimensions > 0);
    for(size_t i = begin; i != end; ++i)
    {
        if constexpr(Dimensions == 1)
        {
            c(i);
        }
        else
        {
            auto bind_an_argument = [i, &c](auto... args)
            {
                c(i, args...);
            };
            meta_for_loop<Dimensions-1>(begin, end, bind_an_argument);
        }
    }
}

解释：

1. 如果维度为 1，我们只需在循环中使用下一个索引调用提供的 lambda
2. 否则，我们从提供的可调用对象创建一个新的可调用对象，只不过我们将循环索引绑定到可调用参数之一。然后我们在元 for 循环上递归，减少 1 维。

如果您非常熟悉函数式编程，那么这会更容易理解，因为它是currying https://en.wikipedia.org/wiki/Currying.

更具体地说它是如何工作的：

你想要一个二进制计数器

0 0
0 1
1 0
1 1

因此，您创建一个可以打印两个整数的可调用函数，如下所示：

auto callable = [](size_t i, size_t j)
{
   std::cout << i << " " << j << std::endl;
};

由于我们有两列，因此有两个维度，因此 D = 2。

我们将上面定义的元 for 循环称为如下：

meta_for_loop<2>(0, 2, callable);

The end论证meta_for_loop是 2 而不是 1，因为我们正在建模一个半闭区间 [start, end)，这在编程中很常见，因为人们经常希望第一个索引包含在循环中，然后他们想要迭代 (end - start)次。

让我们逐步了解该算法：

1. 维度 == 2，所以我们的静态断言不会失败
2. 我们开始迭代，i = 0
3. Dimensions == 2, so we enter the "else" branch of our constexpr if https://en.cppreference.com/w/cpp/language/if statement
   • 我们创建一个新的可调用对象来捕获传入的可调用对象并为其命名bind_an_argument以反映我们正在绑定所提供的可调用对象的一个​​参数c.

So, bind_an_argument实际上看起来像这样：

void bind_an_argument(size_t j)
{
    c(i, j);
}

注意i保持不变，但是j是可变的。这在我们的元 for 循环中很有用，因为我们想要模拟这样一个事实：外部循环保持相同的索引，而内部循环在其整个范围内迭代。 例如

for(int i = 0; i < N; ++i)
{
    for (int j = 0; j < M; ++j)
    {
       /*...*/
    }
}

when i == 0我们迭代所有值j from 0 to M，然后我们重复i == 1, i == 2, etc.

4. We call meta_for_loop再次，除了Dimensions is now 1代替2，以及我们的Callable is now bind_an_argument代替c
5. Dimensions == 1 so our static_assert passes
6. 我们开始循环for(size_t i = 0; i < 2; ++i)
7. Dimensions == 1所以我们输入if我们的分行constexpr if
8. We call bind_an_argument with i = 1, which calls our callable from above with arguments (0, 0), the first of which was bound from the previous call to meta_for_loop. This produces output

   0 0

9. We call bind_an_argument with i == 1, which calls our callable from above with arguments (0, 1), the first argument of which was bound during our previous call to meta_for_loop. This produces output

   0 1

10. 我们完成迭代，因此堆栈展开到父调用函数
11. 我们再次致电meta_for_loop with Dimensions == 2 and Callable == callable。我们完成第一次循环迭代，然后递增i to 1
12. Since Dimensions == 2，我们输入else再次分支
13. Repeat steps 4 through 10, except that the first argument to callable is bound to 1 instead of 0. This produces output

    1 0
    1 1