микро-организмы

/////////////////////////////////////////////////////////////////////////////////////////
//Задается квадрат N x N населенный микроорганизмами, каждую секунду выполняются следущие действия:
//1. Все микроорганизмы имеющие меньше 2-х соседей погибают (соседи- это микроорганизмы живущие в соседних 
//по вертикали либо, по горизонтали, либо по диагонали клетках)
//2. Все микроорганизмы имеющие больше 3-х соседей погибают
//3. Во всех пустых клетках, которые имеют или имели ровно 3 клетки с микроорганизмами, рождаются новые микроорганизмы.
//Input:
//Первый ряд N (1 <= N <= 10) и количесвто пройденных секунд T (1 <= T <=100).
//Второй ряд N рядов по N строк, где 1-микроорганизм, 0- пустая клетка
//Output:
//N рядов по N строк, где 1-микроорганизм, 0- пустая клетка, после T секунд
//Пример 1
//input
//3 1
//0 0 0
//1 1 1
//0 0 0
//output
//0 1 0
//0 1 0
//0 1 0
//Пример 2
//input
//4 100
//0 0 0 0
//0 1 1 0
//0 1 1 0
//0 0 0 0
//output
//0 0 0 0
//0 1 1 0
//0 1 1 0
//0 0 0 0
//Пример 3
//input
//2 10
//1 0
//0 1
//output
//0 0
//0 0 
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
class  T_cell;
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector<T_cell>     T_cells;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_field;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_cell
{
    bool        is_live_;
    T_field*    field_p_;
    int         ind_;
    int         order_;
    int         live_neighbors_counter_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_cell
        (
            int         cell_live_state,
            T_field*    field_p,
            int         ind
        );
    //-----------------------------------------------------------------------------------
    bool  is_live()         const
    {
        return  is_live_;
    }
    //-----------------------------------------------------------------------------------
    int  get_live_state()   const
    {
        return  is_live_;
    }
    //-----------------------------------------------------------------------------------
    void  count_live_neighbors()
    {
        live_neighbors_counter_     =   0;
 
        for ( 
                int  i  =   std::max
                                (
                                    0,
                                    row_ind_from_ind( ind_ ) - 1
                                ); 
        
                i       <=  std::min
                                (
                                    order_ - 1,
                                    row_ind_from_ind( ind_ ) + 1
                                ); 
                
                ++i 
            )
        {
            for (
                    int  j  =   std::max
                                    (
                                        0,
                                        col_ind_from_ind(  ind_ ) - 1
                                    );
 
                    j       <=  std::min
                                    (
                                        order_ - 1,
                                        col_ind_from_ind(  ind_ ) + 1
                                    );
 
                    ++j
                )
            {
                int     neighbor_ind     =   ind_from_row_col(i, j);
                if  ( neighbor_ind  ==  ind_ )
                {
                    continue;
                }
                if  (
                        neighbor_with_ind_is_live( neighbor_ind )
                    )
                {
                    ++live_neighbors_counter_;
                }
            }//for
        }//for
    }
    //-----------------------------------------------------------------------------------
    void  go_to_next_state()
    {
        const int   NEIGHBORS_COUNT_FOR_SURVIVAL            =   2;
        const int   NEIGHBORS_COUNT_FOR_SURVIVAL_OR_BIRTH   =   3;
 
        if( live_neighbors_counter_ == NEIGHBORS_COUNT_FOR_SURVIVAL_OR_BIRTH )
        {
            is_live_ = true;
        }        
        else if( live_neighbors_counter_ != NEIGHBORS_COUNT_FOR_SURVIVAL )
        {
            is_live_ = false;
        }
    }
    //-----------------------------------------------------------------------------------
    int  col_ind_from_ind( int  ind )           const
    {
        return  ind % order_;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    bool  neighbor_with_ind_is_live(int  ind)   const;
    //-----------------------------------------------------------------------------------
    int  row_ind_from_ind( int  ind )           const
    {
        return  ind / order_;
    }
    //-----------------------------------------------------------------------------------
    int  ind_from_row_col
        (
            int     row,
            int     col
        )                                       const
    {
        return  row * order_ + col;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class  T_field
{
    T_cells     cells_;
    int         order_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_field( int  order )
        :
        order_          ( order     )
    {}
    //-----------------------------------------------------------------------------------
    const T_cells&  get_cells()     const
    {
        return  cells_;
    }
    //-----------------------------------------------------------------------------------
    void  append_cell_with_live_state( int  cell_live_state )
    {
        cells_.push_back
            (
                T_cell
                    (
                        cell_live_state,
                        this,
                        cells_.size()
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    void  to_live( int  lifetime )
    {
        for( int  i = 0; i < lifetime; ++i )
        {
            go_to_following_generation();
        }
    }
    //-----------------------------------------------------------------------------------
    void  print()       const
    {
        for( int  i = 0; i < order_ * order_; ++i )
        {
            if( cells_[i].col_ind_from_ind( i ) == 0 )
            {
                std::cout   <<  std::endl;
            }
 
            std::cout   <<  cells_[i].get_live_state()
                        <<  '\t';
        }
    }
    //-----------------------------------------------------------------------------------
    int  order()        const
    {
        return  order_;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void  go_to_following_generation()
    {
        std::for_each
            (
                cells_.begin        (),
                cells_.end          (),
                std::mem_fun_ref    ( &T_cell::count_live_neighbors     )
            );
 
        std::for_each
            (
                cells_.begin        (),
                cells_.end          (),
                std::mem_fun_ref    ( &T_cell::go_to_next_state         )
            );       
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
//Реализация функций класса T_cell, содержащих тип T_field.
//---------------------------------------------------------------------------------------
T_cell::T_cell
    (
        int         cell_live_state,
        T_field*    field_p,
        int         ind
    )
    :
    is_live_                    ( cell_live_state != 0  ),
    field_p_                    ( field_p               ),
    ind_                        ( ind                   ),
    order_                      ( field_p->order()      ),
    live_neighbors_counter_     ( 0                     )
{}
//---------------------------------------------------------------------------------------
bool  T_cell::neighbor_with_ind_is_live(int  ind)       const
{
    return  (
                field_p_->get_cells()
            )
            [ind].is_live();
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_field_cells_states( T_field&    field )
{
    for( int  i = 0; i < field.order(); ++i )
    {
        for( int  j = 0; j < field.order(); ++j )
        {
            if( j % field.order() == 0 )
            {
                std::cout   <<  std::endl;
            }
 
            std::cout   <<  "cell_live_state["
                        <<  i
                        <<  ", "
                        <<  j
                        <<  "] = ";
 
            int     cell_live_state  =   0;
            std::cin    >>  cell_live_state;
            field.append_cell_with_live_state( cell_live_state );
        }//for
    }//for
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
 
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  "matr_order"
                    <<  '\t'
                    <<  "="
                    <<  '\t';
 
        int     matr_order  =   0;
        std::cin    >>  matr_order;
 
        std::cout   <<  "lifetime"
                    <<  '\t' 
                    <<  "="
                    <<  '\t';
 
        int     lifetime    =   0;
        std::cin    >>  lifetime;
 
        T_field     field( matr_order );
 
        std::cout   <<  std::endl;
        input_field_cells_states( field );
 
        field.to_live( lifetime );
 
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  "Результат:";
 
        field.print();
    }//for
}

for (i=0; i<n; i++) for (j=0; j<n; j++) cin>>array[i][j];