Как избежать дублирования кода, когда единственная разница заключается в операторах управления циклами (с теми же операторами в теле цикла)?

В моем решении код для задача Эйлера проекта 11, Я получил следующие функции. Max_consecutive_prod это класс, который рассчитывает максимальное произведение последовательных input()числа, обобщенные из проблема 8. Шесть функций рассчитывают максимальное произведение в разных сериях разных направлений и начинают с разных краев сетки.

Единственная разница в этих функциях — это индексы в for Скажите, как устранить очевидное дублирование? Ситуация здесь как-то противоположна типичному применению template method шаблон: операция идентична, но структура управления отличается, есть ли другой шаблон дизайна для этого?

Изменить: все изменения, указанные в комментариях к (два) for операторы, и тело цикла в каждой функции идентично первой.

template <size_t size> unsigned process_row(const unsigned (&grid)[size][size])
{
unsigned prodMax = 0;
for (int i = 0; i < size; ++i)
{
Max_consecutive_prod mcp;
for (int j = 0; j < size; ++j)
{
mcp.input(grid[i][j]);
}
if (mcp.result() > prodMax)
{
prodMax = mcp.result();
}
}
return prodMax;
}
// exchange i, j in process_row
template <size_t size> unsigned process_col(const unsigned (&grid)[size][size])
{
// ...
}

template <size_t size> unsigned process_diag_lower(const unsigned (&grid)[size][size])
{
unsigned prodMax = 0;
for (int init = 0; init < size; ++init)
{
Max_consecutive_prod mcp;
for (int i = init, j = 0; i < size && j < size; ++i, ++j)
// ...
// ...
}
return prodMax;
}
// exchange i, j in process_diag_lower
template <size_t size> unsigned process_diag_upper(const unsigned (&grid)[size][size])
{
// ...
}
// flip j in process_diag_lower
template <size_t size> unsigned process_rev_diag_lower(const unsigned (&grid)[size][size])
{
unsigned prodMax = 0;
for (int init = 0; init < size; ++init)
{
Max_consecutive_prod mcp;
for (int i = init, j = size-1; i < size && j >= 0; ++i, --j)
// ...
// ...
}
return prodMax;
}
// change ++j in process_diag_upper to --j
template <size_t size> unsigned process_rev_diag_upper(const unsigned (&grid)[size][size])
{
unsigned prodMax = 0;
for (int init = 0; init < size; ++init)
{
Max_consecutive_prod mcp;
for (int j = init, i = 0; j >=0 && i < size; ++i, --j)
// ...
// ...
}
return prodMax;
}

Основываясь на коде случайного хакера, который показывает реальную общность и изменчивость потоков управления шестью функциями, я написал свою версию и сделал код более понятным и идиоматическим в C ++, используя stragegy класс, определяющий локальные переменные для уточнения кода и повышения эффективности. Я определяю не шаблонную версию process(), чтобы избежать раздувания двоичного кода при создании экземпляров для разных size (см. «Эффективный C ++», пункт 44).

Если вы все еще запутались, прочитайте ответ случайного хакера для объяснения. 🙂

namespace Grid_search
{
enum Step { neg = -1, nul, pos };
enum Index_t { i, j };

struct Strategy
{
Step direction[2];
Index_t varOuter;
};

const size_t typeCount = 6;
const Strategy strategy[typeCount] = { {{pos, nul}, i}, {{nul, pos}, j}, {{pos, pos}, i}, {{pos, pos}, j}, {{pos, neg}, i}, {{pos, neg}, j} };
};

template <size_t size> inline unsigned process(const Grid_search::Strategy& strategy, const unsigned (&grid)[size][size])
{
return process(strategy, reinterpret_cast<const unsigned*>(&grid), size);
}

unsigned process(const Grid_search::Strategy& strategy, const unsigned* grid, size_t size)
{
using namespace Grid_search;

const Index_t varOuter = strategy.varOuter, varInner = static_cast<Index_t>(!varOuter);
const Step di = strategy.direction[i], dj = strategy.direction[j];
const unsigned initInner = strategy.direction[varInner] == pos ? 0 : size -1;

unsigned prodMax = 0;
unsigned index[2];
unsigned &indexI = index[i], &indexJ = index[j];
for (unsigned initOuter = 0; initOuter < size; ++initOuter)
{
Max_consecutive_prod mcp;
for (index[varOuter] = initOuter, index[varInner] = initInner;
0 <= indexI && indexI < size && 0 <= indexJ && indexJ < size;
indexI += di, indexJ += dj)
{
mcp.input(grid[indexI*size + indexJ]);
if (mcp.result() > prodMax)
{
prodMax = mcp.result();
}
}
}
return prodMax;
}int main()
{
static const size_t N = 20;
unsigned grid[N][N];

std::ifstream input("d:/pro11.txt");
for (int count = 0; input >> grid[count/N][count%N]; ++count)
{
}

unsigned prodMax = 0;
for (int i = 0; i < Grid_search::typeCount; ++i)
{
unsigned prod = process(Grid_search::strategy[i], grid);
if (prod > prodMax)
{
prodMax = prod;
}
}
}