我有点震惊，没有人提出一些基于算术魔术的循环来完成这项工作。 由于C. Wang 正在寻找没有嵌套循环的解决方案，我会提出一个：
double B[10][8][5];
int index = 0;
while (index < (10 * 8 * 5))
{
const int x = index % 10,
y = (index / 10) % 10,
z = index / 100;
do_something_on_B(B[x][y][z]);
++index;
}
好吧，这种方法既不优雅也不灵活，所以我们可以将所有过程打包到一个模板函数中：
template <typename F, typename T, int X, int Y, int Z>
void iterate_all(T (&xyz)[X][Y][Z], F func)
{
const int limit = X * Y * Z;
int index = 0;
while (index < limit)
{
const int x = index % X,
y = (index / X) % Y,
z = index / (X * Y);
func(xyz[x][y][z]);
++index;
}
}
这个模板函数也可以用嵌套循环的形式表示：
template <typename F, typename T, int X, int Y, int Z>
void iterate_all(T (&xyz)[X][Y][Z], F func)
{
for (auto &yz : xyz)
{
for (auto &z : yz)
{
for (auto &v : z)
{
func(v);
}
}
}
}
并且可以用来提供任意大小的 3D 数组加上函数名，让参数推导完成计算每个维度大小的艰苦工作：
int main()
{
int A[10][8][5] = {{{0, 1}, {2, 3}}, {{4, 5}, {6, 7}}};
int B[7][99][8] = {{{0, 1}, {2, 3}}, {{4, 5}, {6, 7}}};
iterate_all(A, do_something_on_A);
iterate_all(B, do_something_on_B);
return 0;
}
走向更通用
但再一次，它缺乏灵活性，因为它只适用于 3D 数组，但使用 SFINAE 我们可以为任意维度的数组完成工作，首先我们需要一个模板函数来迭代 rank 1 的数组：
template<typename F, typename A>
typename std::enable_if< std::rank<A>::value == 1 >::type
iterate_all(A &xyz, F func)
{
for (auto &v : xyz)
{
func(v);
}
}
另一个迭代任何等级的数组，进行递归：
template<typename F, typename A>
typename std::enable_if< std::rank<A>::value != 1 >::type
iterate_all(A &xyz, F func)
{
for (auto &v : xyz)
{
iterate_all(v, func);
}
}
这允许我们迭代任意维度任意大小数组的所有维度中的所有元素。
使用std::vector
对于多重嵌套向量，解决方案类似于任意维度任意大小的数组之一，但没有 SFINAE：首先我们需要一个模板函数来迭代 std::vectors 并调用所需的函数：
template <typename F, typename T, template<typename, typename> class V>
void iterate_all(V<T, std::allocator<T>> &xyz, F func)
{
for (auto &v : xyz)
{
func(v);
}
}
还有一个模板函数，它迭代任何类型的向量并调用自己：
template <typename F, typename T, template<typename, typename> class V>
void iterate_all(V<V<T, std::allocator<T>>, std::allocator<V<T, std::allocator<T>>>> &xyz, F func)
{
for (auto &v : xyz)
{
iterate_all(v, func);
}
}
无论嵌套级别如何，iterate_all 都会调用向量向量版本，除非向量值版本更好地匹配从而结束递归。
int main()
{
using V0 = std::vector< std::vector< std::vector<int> > >;
using V1 = std::vector< std::vector< std::vector< std::vector< std::vector<int> > > > >;
V0 A0 = {{{0, 1}, {2, 3}}, {{4, 5}, {6, 7}}};
V1 A1 = {{{{{9, 8}, {7, 6}}, {{5, 4}, {3, 2}}}}};
iterate_all(A0, do_something_on_A);
iterate_all(A1, do_something_on_A);
return 0;
}
我认为函数体非常简单直接......我想知道编译器是否可以展开这个循环（我几乎可以肯定大多数编译器都可以展开第一个示例）。
见live demo here。
希望对你有帮助。