многомерный operator[]multidimensional operator[]

До C++23 operator[] был строго ограничен ровно одним параметром — это ограничение унаследовано с самых ранних версий языка. C++23 снимает это ограничение: теперь можно объявить operator[] с произвольным числом параметров, и вызов matrix[i, j] напрямую разрешается в такую перегрузку, без запятой-оператора и без промежуточных объектов.Before C++23, operator[] was strictly limited to exactly one parameter — a restriction inherited from the language's earliest versions. C++23 lifts that restriction: you can now declare operator[] with any number of parameters, and a call like matrix[i, j] resolves directly to such an overload, with no comma operator and no intermediate objects involved.

class Matrix {
public:
    double& operator()(std::size_t i, std::size_t j) {  // круглые скобки вместо привычных []// parens instead of the familiar []
        return data_[i * cols_ + j];
    }
private:
    std::vector<double> data_;
    std::size_t cols_;
};
m(2, 3) = 1.5;  // менее привычный синтаксис для индексации// a less familiar syntax for indexing

class Matrix {
public:
    double& operator[](std::size_t i, std::size_t j) {  // квадратные скобки, несколько параметров// square brackets, multiple parameters
        return data_[i * cols_ + j];
    }
private:
    std::vector<double> data_;
    std::size_t cols_;
};
m[2, 3] = 1.5;  // естественный синтаксис индексации, без proxy// natural indexing syntax, no proxy

Ограничение operator[] одним параметром было чисто исторической случайностью, а не осознанным дизайн-решением — оно годами мешало естественному выражению многомерного доступа:The single-parameter restriction on operator[] was purely a historical accident rather than a deliberate design choice — for years it stood in the way of naturally expressing multidimensional access:

Синтаксически m[i, j] — это не список из двух выражений, разделённых оператором запятая, а специальный список аргументов для operator[], аналогичный списку аргументов при вызове функции. Компилятор напрямую разрешает его в перегрузку operator[](T1, T2, ...) с соответствующим числом параметров, каждый аргумент передаётся отдельно — как в обычном вызове функции с несколькими параметрами.Syntactically, m[i, j] isn't a list of two expressions separated by the comma operator, but a special argument list for operator[], analogous to a function call's argument list. The compiler resolves it directly to an operator[](T1, T2, ...) overload with the matching number of parameters, each argument passed separately — just like an ordinary function call with several parameters.

template<class T>
class Matrix {
public:
    Matrix(std::size_t rows, std::size_t cols)
        : data_(rows * cols), rows_(rows), cols_(cols) {}

    T& operator[](std::size_t i, std::size_t j) {
        return data_[i * cols_ + j];  // i и j пришли как два отдельных параметра// i and j arrive as two separate parameters
    }
    const T& operator[](std::size_t i, std::size_t j) const {
        return data_[i * cols_ + j];
    }
private:
    std::vector<T> data_;
    std::size_t rows_, cols_;
};

Matrix<double> m(3, 3);
m[0, 0] = 1.0;  // напрямую вызывает operator[](0, 0)// directly calls operator[](0, 0)
m[1, 2] = 3.5;

Ровно этот механизм использует std::mdspan: доступ md[i, j, k] по сути вызывает operator[], принимающий столько индексов, сколько измерений (extents) описывает mdspan, и внутренне транслирует их в линейное смещение через объект layout-стратегии (row-major, column-major или произвольный кастомный layout).This is exactly the mechanism std::mdspan uses: an access like md[i, j, k] essentially calls an operator[] taking as many indices as the mdspan's extents describe, internally translating them into a linear offset via a layout-strategy object (row-major, column-major, or an arbitrary custom layout).

std::mdspan md(data.data(), 4, 4);  // 4x4 представление плоского буфера data// a 4x4 view over the flat data buffer
for (std::size_t i = 0; i < md.extent(0); ++i)
    for (std::size_t j = 0; j < md.extent(1); ++j)
        md[i, j] *= 2.0;  // естественный N-мерный синтаксис благодаря этой же фиче// natural N-dimensional syntax thanks to this same feature

• cppreference — operator[]
• WG21 P2128 — multidimensional subscript operator