Нужно заполнить матрицу по спирали

#include <iostream>
#include <vector>
#include <iterator>
#include <map>
#include <array> 
#include <iomanip>
using namespace std;
 
struct Point{
    int x{},y{};
    Point operator+(const Point & pt)const{
        return {pt.x+x, pt.y+y};
    }
    bool operator==(const Point & pt)const{
        return x == pt.x && y == pt.y;
    }
};
enum class Dir{Left, Right, Up, Down};
using PreferedDirs = array<Dir,4>;
    PreferedDirs ClockWiseR{Dir::Right, Dir::Down, Dir::Left, Dir::Up};
    PreferedDirs CounterClockWiseR{Dir::Right, Dir::Up, Dir::Left, Dir::Down};
    PreferedDirs ClockWiseL{Dir::Left, Dir::Up, Dir::Right, Dir::Down};
    PreferedDirs CounterClockWiseL{Dir::Left, Dir::Down, Dir::Right, Dir::Up};
// D2Field must have next operators for access to elements - D2Field_obj[row][col]
template<class T, class D2Field>
class SnakeIterator : forward_iterator_tag{
public:
 
    // if direction of dstart and first prefered direction is same - 
    // first prefered direction shold be the forward!
    // pdirs elements must be unique !
 
    
    SnakeIterator(D2Field & cont, Point csize, Point start, Dir dstart, PreferedDirs pdirs = ClockWiseR) 
                : cont{&cont}, size{csize}, start{start}, dstart{dstart}, pfd{pdirs}, elements{csize.x*csize.y},
                  curre{0}, pcurr{start}, dcurr(dstart), mask{(size_t)csize.x, vector<bool>(size_t(csize.y), false)}{
        mask[pcurr.x][pcurr.y] = true;      
    };
    SnakeIterator begin(){
        return SnakeIterator(*cont, size, start, dstart, pfd);
    }
    SnakeIterator end(){
        SnakeIterator res(*this);
        res.curre = res.elements;
        return res;
    }
    SnakeIterator & operator++(){
        Point p;
        for(const auto dir : pfd){
            p = shifts[Turn(dcurr, dir)] + pcurr;
            if(isInBound(p) && !mask[p.x][p.y]){
                mask[p.x][p.y] = true;
                pcurr = p;
                ++curre;
                dcurr = Turn(dcurr, dir);
                return *this;
            } 
        }
        curre = elements;
        return *this;
    }
    SnakeIterator operator++(int){
       SnakeIterator res(*this);
       ++(*this);
       return res;
    }
    T & operator*(){
        return (*cont)[pcurr.x][pcurr.y];
    };
    const T & operator*() const{
        return (*cont)[pcurr.x][pcurr.y]; 
    };
    bool operator==(const SnakeIterator & si){
        //return memcmp(this, &si, sizeof(*this)) == 0;
        return  curre == si.curre && elements  == si.elements && dcurr  == si.dcurr &&
                mask == si.mask && size == si.size;
    }
    bool operator!=(const SnakeIterator & si){
        return ! this->operator==(si);
    }
    SnakeIterator & operator=(const SnakeIterator&) = default;
    SnakeIterator(const SnakeIterator&) = default;
private:
    D2Field * cont;
    const Point size;
    const Point start;
    const Dir dstart;
    PreferedDirs pfd;
    const int elements;
    int curre;
    Point pcurr;
   // const bool forward;
    Dir dcurr;
    vector<vector<bool>> mask;
    static inline map<Dir, Point> shifts{
        {Dir::Left, {0,-1}},
        {Dir::Right, {0,1}},
        {Dir::Up, {-1,0}},
        {Dir::Down, {1,0}}
    };
    bool isInBound(const Point& pt){
        return ( pt.x >= 0       &&
                 pt.x < size.x   &&
                 pt.y >= 0       &&
                 pt.y < size.y 
        );
    }
    Dir Turn(Dir fron, Dir to){
        switch(fron){
            case Dir::Left : 
                switch(to){
                    case Dir::Left  : return Dir::Down;
                    case Dir::Right : return Dir::Up;
                    case Dir::Up    : return Dir::Left;
                    case Dir::Down  : return Dir::Right;
                    default : return fron;
                }
            case Dir::Right : 
                switch(to){
                    case Dir::Left  : return Dir::Up;
                    case Dir::Right : return Dir::Down;
                    case Dir::Up    : return Dir::Right;
                    case Dir::Down  : return Dir::Left;
                    default : return fron;
                }
            case Dir::Up : 
                    return to;
            case Dir::Down : 
                switch(to){
                    case Dir::Left  : return Dir::Right;
                    case Dir::Right : return Dir::Left;
                    case Dir::Up    : return Dir::Down;
                    case Dir::Down  : return Dir::Up;
                    default : return fron;                    
                }
            default : return fron;
        }
    }
};
 
constexpr size_t rows = 5, cols = 5;
vector<vector<int>> matrix{rows, vector<int>(cols, 0)}; 
 
void snakeTest(Dir dstart, PreferedDirs prefd, Point start ={0,0} ){
 
    SnakeIterator<int, vector<vector<int>>> snakeIt(matrix, {(int)matrix.size(), (int)matrix[0].size()}, start, dstart, prefd);
    int c = rows*cols;
    while(snakeIt != snakeIt.end()){
        *snakeIt = c--;
        ++snakeIt;
    }
    cout << endl;
    for (auto vec : matrix){
        for (auto v : vec)
            cout << setw(2) << v << ' ';
        cout << endl;
    }
}
int main()
{
    snakeTest(Dir::Right, ClockWiseL);
    snakeTest(Dir::Right,  CounterClockWiseR);
 
    
    return 0;
}