std::mdspan

std::mdspan<T, Extents, LayoutPolicy, AccessorPolicy> — невладеющее представление данных как N-мерного массива поверх единого буфера памяти. Extents задают размерность и размеры по каждой оси — статические (известные на этапе компиляции), динамические (известные в рантайме), или смешанные. LayoutPolicy определяет, как индексы [i, j, k] транслируются в линейный офсет: row-major/C-order по умолчанию через layout_right, column-major/Fortran-order через layout_left, или произвольный strided layout для нестандартной раскладки данных.A std::mdspan<T, Extents, LayoutPolicy, AccessorPolicy> is a non-owning view of data as an N-dimensional array over a single memory buffer. Extents specify the dimensionality and size along each axis — static (known at compile time), dynamic (known at runtime), or a mix of both. LayoutPolicy defines how indices [i, j, k] translate to a linear offset: row-major/C-order by default via layout_right, column-major/Fortran-order via layout_left, or an arbitrary strided layout for a non-standard data arrangement.

void process_matrix(double* data, std::size_t rows, std::size_t cols) {
    for (std::size_t i = 0; i < rows; ++i) {
        for (std::size_t j = 0; j < cols; ++j) {
            // формула офсета разбросана по всему коду,// the offset formula is scattered across the code,
            // легко ошибиться в row-major vs column-major// easy to mix up row-major vs column-major
            data[i * cols + j] *= 2.0;
        }
    }
}

void process_matrix(std::mdspan<double, std::dextents<std::size_t, 2>> m) {
    for (std::size_t i = 0; i < m.extent(0); ++i) {
        for (std::size_t j = 0; j < m.extent(1); ++j) {
            m[i, j] *= 2.0;  // офсет считает layout policy, не программист// the layout policy computes the offset, not the programmer
        }
    }
}

Представление многомерных данных без владения/копирования до mdspan упиралось в одну из двух неудачных крайностей:Representing multidimensional data without owning/copying it, before mdspan, boiled down to one of two unsatisfying extremes:

Под капотом mdspan, как и span (см. cpp20/span.html), — это просто указатель плюс метаданные, ничего не аллоцирующие и не освобождающие. Разница со span в том, что метаданных больше: не одно число "длина", а объект Extents, описывающий размер по каждой из N осей, плюс LayoutPolicy, отвечающий за перевод многомерного индекса в линейный офсет внутри буфера.Under the hood, mdspan — like span (see cpp20/span.html) — is just a pointer plus metadata, allocating and freeing nothing. The difference from span is that there's more metadata: not a single "length" number, but an Extents object describing the size along each of N axes, plus a LayoutPolicy responsible for translating a multidimensional index into a linear offset inside the buffer.

#include <mdspan>

double data[12] = {1,2,3,4, 5,6,7,8, 9,10,11,12};

// статические extents — 3 строки, 4 столбца, известно на этапе компиляции// static extents — 3 rows, 4 columns, known at compile time
std::mdspan<double, std::extents<std::size_t, 3, 4>> m(data);

for (std::size_t i = 0; i < m.extent(0); ++i)
    for (std::size_t j = 0; j < m.extent(1); ++j)
        m[i, j] = 0.0;  // многомерный operator[] из этого же стандарта// the multidimensional operator[] from this same standard
// см. cpp23/multidim-subscript.html — новый operator[] с несколькими аргументами// see cpp23/multidim-subscript.html — the new multi-argument operator[]

Смена layout policy меняет только формулу офсета, не требуя ничего от вызывающего кода, работающего через operator[] — но, как показано ниже, layout_right и layout_left дают разную физическую раскладку одних и тех же логических индексов в памяти:Switching the layout policy only changes the offset formula, requiring nothing from calling code that goes through operator[] — but, as shown below, layout_right and layout_left give the same logical indices a different physical layout in memory:

int buf[6] = {0, 1, 2, 3, 4, 5};

// layout_right (по умолчанию) — row-major/C-order: строка идёт подряд в памяти// layout_right (default) — row-major/C-order: a row is contiguous in memory
std::mdspan<int, std::extents<std::size_t, 2, 3>, std::layout_right> row_major(buf);
// row_major[0, 1] == buf[1], row_major[1, 0] == buf[3]// row_major[0, 1] == buf[1], row_major[1, 0] == buf[3]

// layout_left — column-major/Fortran-order: столбец идёт подряд в памяти// layout_left — column-major/Fortran-order: a column is contiguous in memory
std::mdspan<int, std::extents<std::size_t, 2, 3>, std::layout_left> col_major(buf);
// col_major[0, 1] == buf[2], col_major[1, 0] == buf[1] — те же индексы, другой буфер-офсет// col_major[0, 1] == buf[2], col_major[1, 0] == buf[1] — same indices, different buffer offset

• cppreference — std::mdspan
• WG21 P0009 — mdspan