Question

我有一个Vec3课程。替换像

这样的循环的最佳方法是什么

for (int x = 20; x < 25; x++)
    for (int y = 40; y < 45; y++)
        for (int z = 2; z < 4; z++) doStuff({x,y,z});

有这样的事情：

for(Vec3 v: Vec3range({20,40,2}, {25,45,4}))
    doStuff(v);

没有任何运行时成本？

Answer 1

为此，我在functional library fn中写了迭代和组合适配器：

#include <fn.h>
#include <iostream>

int main() {
    using std; using fn;

    for (auto &&values : combine(seq(20,25), seq(40,45), seq(2,4))) {
        int x, y, z; 
        tie(x, y, z) = values;
        cout << x << ", " << y << ", " << z << "\n";
        // or in your case: doStuff({x, y, z});
    }
}

输出：

20, 40, 2
20, 40, 3
20, 41, 2
20, 41, 3
...
24, 43, 2
24, 43, 3
24, 44, 2
24, 44, 3

此处，seq(a, b)返回隐式范围，遍历值[a, b) （即第一个包含，第二个包含）。（第三个参数可以指定步骤，并且存在更复杂的替代方案，以便更好地控制迭代。）

函数combine(ranges...)返回一个隐式范围，迭代给定范围的所有组合（其中第一个被认为是“最重要的”组合，类似于“最外层” “循环）。它的迭代器取消引用保存当前组合的std::tuple。

然后，这个元组在循环体中绑定到一些变量。（遗憾的是，基于范围的for循环没有“自动绑定”，如for(tie(auto x, auto y, auto z) : ...)。）

实现：

`seq()`

这很简单：它是一个返回具有begin()和end()函数的适配器对象的函数。它们返回一个自定义迭代器，它会增加operator++中的当前值并将其返回operator*。

`combine()`

这更有趣：它返回一个适配器对象，该对象保存作为元组成员中combine的参数提供的范围。这个适配器的迭代器将迭代器保存到元组成员中的包装范围，但是三次：当前位置，开始和结束，你很快就会明白为什么。

迭代器的operator++很可能是最有趣的一个：它是使用variadic_ops.h, va_next_combination()中的可变参数模板递归实现的，它给出了迭代器的三元组（对于每个范围，当前，开始和结束））：

// base case
inline bool va_next_combination() {
    return true;
}

// recursive case
template<typename Head, typename ...Tail>
inline bool va_next_combination(std::tuple<Head&,Head&,Head&> && curr_and_begin_and_end, std::tuple<Tail&,Tail&,Tail&> &&...t) {
    // advance the "tail" to its next combination and check if it had an overflow
    if (va_next_combination(std::forward<std::tuple<Tail&,Tail&,Tail&>>(t)...)) {
        // advance the "head" iterator
        ++std::get<0>(curr_and_begin_and_end);
        // check if the "head" just overflow
        bool at_end = (std::get<0>(curr_and_begin_and_end) == std::get<2>(curr_and_begin_and_end));
        // if it did, put it back to the beginning and report the overflow
        if (at_end) std::get<0>(curr_and_begin_and_end) = std::get<1>(curr_and_begin_and_end);
        return at_end;
    } else {
        // "tail" didn't overflow, so we do nothing and no overflow should be reported
        return false;
    }
}

从集合中最右边的迭代器开始，它会递增迭代器。如果它刚刚到达范围的末尾，它会将其报告为递归函数的返回值。下一个迭代器检查该值，如果它是真的，则需要提前（否则不）以及“重置”右边的迭代器（即“环绕”它的溢出），最后它将相同的信息报告给在左边。

如果你从最深的递归级别的“if”条件开始，那基本上就是机械计数器的工作原理。

Answer 2

template<size_t N>
using indexes=std::array<size_t,N>;

template<size_t N>
void advance( indexes<N>& in, indexes<N-1> const& limit, size_t amt=1 );

进一步找到索引amt，在极限处回绕。

然后写一个范围对象。它存储限制和两个迭代器，b和e。 begin会返回b和end e。

迭代器有一个指向它们来自范围的指针和一组值。他们++通过next以上。编写通常的前向迭代器样板。

您的功能可能应该是：

template<size_t N>
multi_range_t<N> multi_range( indexes<N> start, indexes<N> finish );

要求您传递N。

最后从Vec3撰写std::array<3,T>的副本ctor。

您可以通过将其设为3而不是N来轻松触摸，但只需触摸即可。

Answer 3

这是我能管理的最简单的实现：

#include <iostream>
#include <tuple>

using namespace std;

using tuple_3d = tuple<int, int, int>;

struct range_3d;

struct range_3d_iterator
{
  const range_3d& c;
  tuple_3d i;

  bool operator!=(const range_3d_iterator& other)
  { return get<0>(i) != get<0>(other.i) && get<1>(i) != get<1>(other.i) && get<2>(i) != get<2>(other.i); }

  tuple_3d operator*() const
  { return make_tuple(get<0>(i), get<1>(i), get<2>(i)); }

  const range_3d_iterator& operator++();
};

struct range_3d
{
  tuple_3d s;
  tuple_3d e;

  range_3d_iterator begin() const
  { return { *this, s }; }

  range_3d_iterator end() const
  { return { *this, e }; }
};

const range_3d_iterator& range_3d_iterator::operator++()
{
  ++get<2>(i);
  if (get<2>(i) == get<2>(c.e))
  {
    get<2>(i) = get<2>(c.s);
    ++get<1>(i);
    if (get<1>(i) == get<1>(c.e))
    {
      get<1>(i) = get<1>(c.s);
      ++get<0>(i);
    }
  }
  return *this;
}

int main(void)
{
  for (auto&& v : range_3d{ make_tuple(20, 40, 2), make_tuple(25, 45, 4) })
    cout << get<0>(v) << ' ' << get<1>(v) << ' ' << get<2>(v) << endl;  
}

命名有点废话，但除此之外，这个概念很简单。 range_3d是一个简单的类，支持begin()，end()以获取循环的工作范围，然后是＆＃34;智能＆＃34;在range_3d_iterator中将迭代元组。鉴于我在这里使用元组的方式，将其扩展到任意维度是微不足道的......

TBH，原来的循环非常清楚...... IMO！

用基于范围的for循环替换多维for循环

3 个答案:

实现：

`seq()`

`combine()`