Заполнить матрицу

#include<iostream>
#include<iomanip>
 
const size_t m = 9;//Фиксированное значение.
const size_t n = 10;//Может быть любым >= 5.
 
int matrix[m][n];
 
struct T_point
{
    size_t i_;
    size_t j_;
    T_point
        (
            size_t  i = 0,
            size_t  j = 0
        ) : i_(i), j_(j)
    {}
 
    bool operator== (T_point p)
    {
        return i_ == p.i_ && j_ == p.j_;
    }
 
    bool operator!= (T_point p)
    {
        return !(*this == p);
    }
};
 
size_t  val = 1;
 
void fill_line
    (
        T_point&  p_beg,
        int       i_shift,
        int       j_shift
    )
{ 
    T_point  p_end(p_beg.i_ + i_shift, p_beg.j_ + j_shift);
    int i_step = i_shift ? i_shift / abs(i_shift) : 0; 
    int j_step = j_shift ? j_shift / abs(j_shift) : 0;
    
    for( ; p_beg != p_end; p_beg.i_ += i_step, p_beg.j_ += j_step, ++val)
    {
        matrix[p_beg.i_][p_beg.j_] = val;        
        matrix[m - 1 - p_beg.i_][n - 1 - p_beg.j_] = m * n + 1 - val;        
    }
}
 
void  fill_line_vniz
    (
        T_point&  p_beg,        
        int       vniz_shift
    )
 
{
    fill_line(p_beg, vniz_shift, 0);    
}
 
void fill_line_vverx
    (
        T_point&  p_beg,        
        int       vverx_shift
    )
 
{
    fill_line(p_beg, -vverx_shift, 0);    
}
 
void fill_line_vpravo
    (
        T_point&  p_beg,        
        int       vpravo_shift
    )
 
{
    fill_line(p_beg, 0, vpravo_shift);    
}
 
void fill_line_vlevo
    (
        T_point&  p_beg,        
        int       vlevo_shift
    )
 
{
    fill_line(p_beg, 0, -vlevo_shift);    
}
 
void fill_oborot_vlevo
    (
        T_point&  p_beg,        
        size_t&   vert_abs_shift,
        size_t&   horis_abs_shift
    )
{    
    fill_line_vpravo (p_beg, horis_abs_shift++);
    fill_line_vverx  (p_beg, vert_abs_shift++);
    fill_line_vlevo  (p_beg, horis_abs_shift++);
    fill_line_vniz   (p_beg, vert_abs_shift++);
}
 
void fill_matrix()
{
    T_point  p_beg(2, 2);
    size_t   vert_abs_shift   = 1;
    size_t   horis_abs_shift  = n - 4;
    
    for(size_t oborot_count = 1; oborot_count <= 2; ++oborot_count)
    {
        fill_oborot_vlevo(p_beg, vert_abs_shift, horis_abs_shift);
    }    
    fill_line_vpravo(p_beg, (n + 1) / 2);
}
 
void print_matrix()
{
    for(size_t i = 0; i < m; ++i)
    {
        for(size_t j = 0; j < n; ++j)
        {            
            std::cout << std::setw(5) << matrix[i][j];
        }
        std::cout << std::endl;
    }
}
 
int main()
{
    fill_matrix();
    print_matrix();
    return 0;
}

#include<iostream>
#include<iomanip>
 
const int m = 9;//Фиксированное значение.
const int n = 10;//Может быть любым >= 5.
 
const int EMPTY_VAL  = 0;
int matrix[m][n]     = {EMPTY_VAL};
 
enum T_napravl
{
    VLEVO,
    VVERX,
    VPRAVO,
    VNIZ,
    MAX_NAPRAVL_COUNT
};
 
void fill_cell
    (
        int  i, 
        int  j,
        int  val
    )
{
    matrix[i][j] = val;        
    matrix[m - 1 - i][n - 1 - j] = m * n + 1 - val;    
}
 
bool is_correct_empty_cell(int i, int j)
{
    return    0 <= i && i < m
           && 0 <= j && j < n
           && matrix[i][j] == EMPTY_VAL;
}
 
bool good_go_to_cell
    (
        int& i,
        int& j,
        int  i_new,
        int  j_new
    )
{
    bool res;    
    if(res = is_correct_empty_cell(i_new, j_new))
    {
        i = i_new;   
        j = j_new;        
    }
    return res;     
}
 
bool good_go_to_napravl
    (
        T_napravl  napravl,
        int&       i,
        int&       j
    )
{
    switch(napravl)
    {
    case VLEVO  : return good_go_to_cell(i,  j,  i,      j - 1);
    case VVERX  : return good_go_to_cell(i,  j,  i - 1,  j    );
    case VPRAVO : return good_go_to_cell(i,  j,  i,      j + 1);
    case VNIZ   : return good_go_to_cell(i,  j,  i + 1,  j    );
    default     : return false;
    }
}
 
bool get_next_cell(int& i, int& j)
{    
    static T_napravl  cur_napravl = VLEVO;
    for(int napravl_count = 0; napravl_count < MAX_NAPRAVL_COUNT; ++napravl_count)
    {
        cur_napravl 
            = static_cast<T_napravl>((cur_napravl + napravl_count) % MAX_NAPRAVL_COUNT);
        if(good_go_to_napravl(cur_napravl, i, j))
        {             
            return true;
        }
    }    
    return false;
}
 
void fill_matrix()
{
    int  val  = (m * n + 1) / 2;
    int  i    = (m - 1)     / 2;
    int  j    = (n - 1)     / 2;
    do
    {
        fill_cell(i, j, val--);        
    }while(get_next_cell(i, j));
}
 
void print_matrix()
{
    for(int i = 0; i < m; ++i)
    {
        for(int j = 0; j < n; ++j)
        {            
            std::cout << std::setw(5) << matrix[i][j];
        }
        std::cout << std::endl;
    }
}
 
int main()
{
    fill_matrix();
    print_matrix();
    return 0;
}