Заполнение массива по определенной схеме

#include <iostream>
 
class foo
{
    int* pData;
    size_t mRows, mCols;
 
    friend std::ostream& operator<<(std::ostream& os, const foo& obj) {
        std::streamsize osw = os.width();
        for (size_t i = 0; i < obj.mRows; ++i) {
            for (size_t j = 0; j < obj.mCols; ++j) {
                os.width(osw);
                os << obj.pData[i * obj.mCols + j];
            }
            os << '\n';
        }
        return os;
    }
 
    bool is_valid(size_t row, size_t col) {
        return row < mRows && col < mCols && !pData[row * mCols + col];
    }
 
public:
    ~foo() { delete[] pData; }
    foo(size_t rows, size_t cols) :
        mRows(rows),
        mCols(cols),
        pData(new int[rows * cols]{})
    {}
 
    foo& bar() {
        int8_t dX[]{ 0,-1, 0, 1 };
        int8_t dY[]{-1, 0, 1, 0 };
        int8_t dir = 0;
        size_t x = mRows - 1, y = mCols - 1;
        for (size_t i = 1; i <= mRows * mCols; ++i) {
            pData[x * mCols + y] = i;
            if (!is_valid(x + dX[dir], y + dY[dir])) {
                dir = dir == 3 ? 0 : dir + 1;
            }
            x += dX[dir];
            y += dY[dir];
        }
        return *this;
    }
};
 
int main()
{
    size_t rows, cols;
    std::cin >> rows >> cols;
    std::cout.width(3);
    std::cout << foo(rows, cols).bar() << '\n';
 
    return 0;
}