Задача на поиск маршрута

#include <iostream>
 
int dir_shifts[8][2]{
    {-1, +1}, {0, +1}, {+1, +1}, {+1, 0}, 
    {+1, -1}, {0, -1}, {-1, -1}, {-1, 0},
};
 
enum class PointState{Empty, Visited, Destination};
 
struct PathFinder{
    PathFinder(int* field, int r, int c, int* dirs, int dirs_count, int sx, int sy, int tox, int toy)
        : field{field}, r{r}, c{c}, dirs{dirs}, dirs_count{dirs_count}, sx{sx}, sy{sy}, tox{tox}, toy{toy}, path{new int [c*r*2]}, path_steps{0}, step{path}{
    }
    int* operator()(){
        field[toy*r + tox] = (int)PointState::Destination;
        field[sy*r + sx] = (int)PointState::Visited;
        if (!find_path_R(sx, sy))
            return nullptr;  
        // set the terminator
        *(step++) = -1;
        *(step++) = -1;
        return path;
 
    }
    ~PathFinder(){
        delete [] path;
    }
    PathFinder(const PathFinder&) = delete;
    PathFinder& operator=(const PathFinder&) = delete;
private :
    int* field, r, c;
    int* dirs, dirs_count;
    int sx, sy, tox, toy;
    
    // path is a pair of coordiantes (x, y), where (-1,-1) indicate the path end 
    int* path;
    int  path_steps;
    int* step;
    bool is_can_final_step(int x, int y){
        for(int i = 0; i < dirs_count; ++i ){
            int nx = x + dir_shifts[dirs[i]][0];
            int ny = y + dir_shifts[dirs[i]][1];
            while(is_in_bound(nx, ny)){
                if (at(nx, ny) == (int)PointState::Destination)
                    return true;
                nx += dir_shifts[dirs[i]][0];
                ny += dir_shifts[dirs[i]][1];
            }
        }
        return false;
    }
    bool find_path_R(int x, int y){
        if (is_can_final_step(x, y)){
            *(step++) = x;
            *(step++) = y;
            ++path_steps;
            return true;
        }
        for(int i = 0; i < dirs_count; ++i ){
            int nx = x + dir_shifts[dirs[i]][0];
            int ny = y + dir_shifts[dirs[i]][1];
            while(is_in_bound(nx, ny) && is_empty(nx, ny)){
                at(nx, ny) = (int)PointState::Visited;
                if (find_path_R(nx, ny)){
                    *(step++) = x;
                    *(step++) = y;
                    return true;
                }
                nx += dir_shifts[dirs[i]][0];
                ny += dir_shifts[dirs[i]][1];
            }
        }
        return false;
    }
    bool is_in_bound(int x, int y){
        return (x>=0 && x<c && y>=0 && y<r);
    }
    bool is_empty(int x, int y){
        return (at(x,y) == (int)PointState::Empty);
    }
    int& at(int x, int y){
        // if (!is_in_bound(x, y))
        //   throw std::exception::range_error("Field coordinate out of range.");
        return field[r*y+x];
    }
};
 
int main()
{
 
    const int N = 8, M = 8; // N - rows, M - columns
    // field orientation : (0, 0) is left down and n-1, m-1 is a right top
    int field[N*M]{};
    // direction : 0 - to left top, next by clockwise, to 7 included
    // int dirs[]{0, 2, 4, 6, 1};
    int dirs[]{0, 2, 4, 6, 3};
    int start_point_x = 0, start_point_y = 0;
    int dest_point_x = 6, dest_point_y = 7;
 
    PathFinder pf(field, N, M, dirs, sizeof(dirs)/sizeof(dirs[0]), start_point_x, start_point_y, dest_point_x, dest_point_y);
    int* path = pf();
    if ( path ){
        // unwind path
        int x = *(path++);
        int y = *(path++);
        while(x!=-1){
            std::cout << "(" << x << ", " << y << ")" << std::endl;
            x = *(path++);
            y = *(path++);
        }
    }else
        std::cout << "Path not found" << std::endl;
}