Найти квадратные подматрицы, которые симметричны относительно главной диагонали

#include <iostream>
#include <iomanip>
#include <vector>
#include <cassert>
//////////////////////////////////////////////////////////////////////////////////////
// шаблон класса матриц
template<class T> class Matrix
{
    size_t m_rows;
    size_t m_cols;
    std::vector<T> m_data;
 
public:
 
    Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols), m_data(rows* cols)
    {
        assert(m_rows && m_cols);
        assert(m_rows <= m_data.max_size() / m_cols);
    }
 
    T* operator[](size_t row) { return m_data.data() + row * m_cols; }
    const T* operator[](size_t row) const { return m_data.data() + row * m_cols; }
 
    size_t rows() const { return m_rows; }
    size_t cols() const { return m_cols; }
};
//////////////////////////////////////////////////////////////////////////////////////
// шаблон класса подматрицы, имеет ссылочную семантику и похожий интерфейс
template<class T> class Sub_mat_cref
{
    size_t m_row;
    size_t m_col;
    size_t m_rows;
    size_t m_cols;
    const Matrix<T>& ref;
 
public:
 
    Sub_mat_cref(size_t row, size_t col, size_t rows, size_t cols, Matrix<T>& mat)
        : m_row(row), m_col(col), m_rows(rows), m_cols(cols), ref(mat)
    {
        assert(m_rows && m_cols);
        assert(m_row + m_rows <= ref.rows());
        assert(m_col + m_cols <= ref.cols());
    }
 
    const T* operator[](size_t row) const
    {
        return ref[row + m_row] + m_col;
    }
 
    size_t rows() const { return m_rows; }
    size_t cols() const { return m_cols; }
};
//////////////////////////////////////////////////////////////////////////////////////
// на это не обращай внимания, можно просто написать две перегрузки с идентичным кодом
#include <type_traits>
template<
    template<class> class M,
    class T,
    typename = std::enable_if_t<std::is_same<M<T>, Matrix<T>>::value || std::is_same<M<T>, Sub_mat_cref<T>>::value>
>
std::ostream& operator<<(std::ostream& os, const M<T>& mat)
{
    for (size_t row{}; row < mat.rows(); ++row)
    {
        for (size_t col{}; col < mat.cols(); ++col)
        {
            os << std::setw(6) << mat[row][col];
        }
        os << std::endl;
    }
    return os;
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    constexpr size_t rows = 3;
    constexpr size_t cols = 5;
    constexpr size_t sub_size = 2;
 
    Matrix<int> mat(rows, cols);
    // заполняем основную матрицу
    for (size_t row{}; row < mat.rows(); ++row)
    {
        for (size_t col{}; col < mat.cols(); ++col)
        {
            mat[row][col] = row * cols + col;
        }
    }
    // выводим на экран основную матрицу
    std::cout << "Source:\n";
    std::cout << mat << std::endl;
    // выводим на экран все подматрицы 2x2 основной матрицы
    std::cout << "Subs2x2:\n";
    for (size_t row{}; row <= mat.rows() - sub_size; ++row)
    {
        for (size_t col{}; col <= mat.cols() - sub_size; ++col)
        {
            std::cout << Sub_mat_cref<int>(row, col, sub_size, sub_size, mat) << std::endl;
        }
    }
}