• value_type в данном случае это просто int

using value_type = int;

• Принимает на вход размер пещеры и шанс начальной инициализации

• Для генерации будет использовать средства из стандартной библиотеки <random> C++11

return_type InitializeRandom(value_type rows, value_type cols, value_type live_chance) {
    std::default_random_engine re(std::chrono::system_clock::now().time_since_epoch().count());
    std::uniform_int_distribution <value_type> dist(0, 100);

    // data_type -> std::vector<value_type>
    return_type::data_type generation(rows * cols);
    std::generate(generation.begin(), generation.end(), [&dist, &re, live_chance] {
        value_type chance = dist(re);
        return chance <= live_chance ? 1 : 0;
    });
    return {generation, rows, cols};
}

• Клетку будем считать живой, если сгенерированное число меньше live_chance

• Для генерирования (псевдо-)случайных чисел, движок будет инициализироваться seed'ом, зависящим от системного времени, используя для этого стандартную библиотеку <chrono>

template <> struct DataWrapper<kCave> final {
    using value_type = int;
    using data_type = std::vector<value_type>;

    data_type data;
    value_type rows = 0, cols = 0;

    int &operator()(std::size_t row, std::size_t col) {
        return data[row * cols + col];
    }

    int  operator()(std::size_t row, std::size_t col) const {
        if (row >= rows or col >= cols)
            return 1;
        return data[row * cols + col];
    }
}; 

Окре́стность Му́ра клетки (англ. Moore neighborhood) — в двумерном случае — совокупность восьми клеток на квадратном паркете, имеющих общую вершину с данной клеткой.

• Функция принимает номер строки и столбца а также сам массив для проверки соседей

value_type CountLiveNeighbours(value_type row, value_type col, const return_type &cave) {
    value_type count = 0;
    for (auto item: {cave(row, col - 1), cave(row, col + 1), cave(row - 1, col), cave(row + 1, col),
                     cave(row - 1, col - 1), cave(row - 1, col + 1), cave(row + 1, col - 1),
                     cave(row + 1, col + 1)})
        if (item != 0)
            count++;
    return count;
}

• Если текущая клетка жива и количество соседей находится в пределе live_limit, то клетка остается живой, иначе умирает.

std::pair<value_type, value_type> live_limit

• Если текущая клетка мертва и количество соседей находится в пределе born_limit, то клетка оживает, иначе остается мертвой.

std::pair<value_type, value_type> born_limit

• После определения состояния каждой клетки, из буфера, хранящего новое поколение, нужно скопировать с основной массив (для генерации последующих поколений)

return_type Generate(const GenerationSettings &s) {
    return_type cave{InitializeRandom(s.rows, s.cols, s.live_chance)}, tmp = cave;
    value_type generation = 0;
    while (generation++ != s.generation_count) {
        for (value_type row = 0; row != cave.rows; ++row) {
            for (value_type col = 0; col != cave.cols; ++col) {
                value_type count = CountLiveNeighbours(row, col, cave);
                if (cave(row, col) == 1 and (count < s.live_limit.first or count > s.live_limit.second))
                    tmp(row, col) = 0;
                else if (cave(row, col) == 0 and (count >= s.born_limit.first and count <= s.born_limit.second))
                    tmp(row, col) = 1;
            }
        }
        std::copy(tmp.data.begin(), tmp.data.end(), cave.data.begin());
    }
    return cave;
}