Я был шокирован тем, что никто не предложил какой-то цикл, основанный на арифметической магии, для выполнения этой работы. Поскольку К. Ван ищет решение без вложенных циклов , я предлагаю одно:
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);
}
}
}
}
И может использоваться, предоставляя трехмерный массив произвольного размера плюс имя функции, позволяя вычету параметра выполнять тяжелую работу по подсчету размера каждого измерения:
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 мы можем выполнять работу для массивов произвольного измерения, сначала нам нужна функция шаблона, которая выполняет итерацию массивов ранга 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;
}
Я думаю, что тело функции довольно простое и прямолинейное ... Интересно, сможет ли компилятор развернуть эти циклы (я почти уверен, что большинство компиляторов могли бы развернуть первый пример).
Смотрите живую демонстрацию здесь .
Надеюсь, поможет.