C++23 把連續資料當成多維陣列存取的容器：mdspan

首先，他最簡單的使用情境大概會是下面的樣子：

#include <array>
#include <mdspan>
#include <iostream>
 
int main()
{
  // 1D data
  std::array<char, 24> aData;
  for (size_t i = 0; i < aData.size(); ++i)
    aData[i] = 'a' + i;
 
  // 2D view as matrix
  std::mdspan matrix(aData.data(), 4, 6);
 
  // output matrix
  for (size_t i = 0; i != matrix.extent(0); ++i)
  {
    for (size_t j = 0; j != matrix.extent(1); ++j)
      std::cout << matrix[i, j] << " ";
    std::cout << "\n";
  }
}

這樣的程式最後輸出的結果會是下面的樣子：

a b c d e f
g h i j k l
m n o p q r
s t u v w x

在上面的例子裡面，是先定義一個長度是 24 的一維陣列資料 aData 出來，然後裡面填入 a – x 的字元。

接下來，則是透過 std::mdspan 把 aData 從新封裝成一個 4×6 的二維陣列 matrix。
這邊要注意的是，和 std::span 一樣，他並沒有資料的所有權、只是一個「view」而已。

這邊宣告的型別雖然只有寫 std::mdspan，但是實際上他是 template 型別，他會根據初始化條件和預設值來決定 template 參數；在 MSVC 他實際上的型別會是

std::mdspan<char,
            std::extents<unsigned __int64, -1, -1>,
            std::layout_right,
            std::default_accessor<char>>

不過細節的部份，就之後再說明了。

在把 std::array 的資料封裝成 std::mdspan 之後呢，就可以把 matrix 當作二維陣列來操作、進行存取了！

這邊可以透過 extent() 這個函式、來取得指定軸向的大小；而之後，則可以透過 operator[] 來存取資料，使用上應該還算直覺。

不過很可惜的，雖然 Visual Studio 2022 17.9 已經支援了 std::mdspan，但是上面的程式是編譯不過的。

這是因為就算是目前最新的 Visual Studio 2022 17.11、C++ 核心語言的部分還是不支援多維度 subscript operator（[]） ，所以 matrix[ i, j ] 這樣的存取方法是不能使用的… orz

現階段要使用 MSVC 的 std::mdspan 需要把索引值先封裝成 std::array 或是使用 std::span 才行，也就是說要存取 (i, j) 的時候，需要透過 matrix[std::array{i,j}] 這樣的形式才行。

這邊大概就只能看微軟什麼時候要支援了？

std::mdspan 的支援性不限於二維，也可以應用在更高維度。像是如果以上面同樣的 aData 來說，這邊也可以封裝成三維的形式來存取。

// 3D view as volume
std::mdspan volume(aData.data(), 2, 3, 4);

// output volume
for (size_t i = 0; i != volume.extent(0); ++i)
{
  for (size_t j = 0; j != volume.extent(1); ++j)
  {
    for (size_t k = 0; k != volume.extent(2); ++k)
      std::cout << volume[i, j, k] << " ";
    std::cout << "\n";
  }
  std::cout << "\n";
}

這邊基本上就是把大小是 24 的一維陣列、封裝成 2 x 3 x 4 的三維陣列了～它的結果會是：

a b c d
e f g h
i j k l

m n o p
q r s t
u v w x

上面算是最基本的使用情境。而實際上，std::mdspan 也是一個彈性滿大的 template 容器，也有相當大的使用彈性。

他實際上的型別是：

template<
  class T,
  class Extents,
  class LayoutPolicy = std::layout_right,
  class AccessorPolicy = std::default_accessor<T>
> class mdspan;

他的 template 參數總共有四個：

• 代表資料型別的 T
• 代表維度資訊的 Extents
• 代表記憶體布局方法的 LayoutPolicy
• 代表存取方式的 AccessorPolicy

在上面的使用情境，基本上這些參數就都是根據建構時的參數來自動推論出來的了。

下面則是一些說明：

維度資訊（extents）

std::mdspan view1(aData.data(), 2, 3);
std::mdspan<char, std::dextents<int, 2>> view2(aData.data(), 2, 3);
std::mdspan<char, std::extents<int, 2, 3>> view3(aData.data());
std::mdspan<char, std::extents<int, 2, std::dynamic_extent>> view4(aData.data(), 3);

std::mdspan view2(aData.data(), std::dextents< int, 2 >(2, 3));
std::mdspan view3(aData.data(), std::extents< int, 2, 3 >());

資料配置（layout）

std::mdspan view1(aData.data(), 2, 3);
// a b c
// d e f

std::mdspan<char, std::extents<int,2,3>, std::layout_left> view2(aData.data());
// a c e
// b d f

存取方法（accessor）

最後，這邊再提一下 std::mdspan 的軸向的順序。

如果是要把一維陣列當作二維陣列存取的時候，Heresy 這邊其實是習慣用 x + y * width 這樣的計算公式。比較簡單的例子，大概會是下面這樣：

std::array<char, 12> aData;
for (size_t i = 0; i < aData.size(); ++i)
  aData[i] = 'a' + i;

size_t width = 4, height = 3;
std::cout << "Matrix " << width << '/' << height << ":\n";
for (size_t y = 0; y < height; ++y)
{
  for (size_t x = 0; x < width; ++x)
    std::cout << aData[x + y * width] << " ";
  std::cout << "\n";
}

這樣的結果會是：

Matrix 4/3:
a b c d
e f g h
i j k l

而使用 std::mdspan 的時候，如果很直覺地寫成下面的型式的話：

std::mdspan matrix(aData.data(), 4, 3);
std::cout << "Matrix " << matrix.extent(0) << " / " << matrix.extent(1) << "\n";
for (size_t y = 0; y != matrix.extent(1); ++y)
{
  for (size_t x = 0; x != matrix.extent(0); ++x)
    std::cout << matrix[std::array{ x, y }] << " ";
  std::cout << "\n";
}

結果會是：

Matrix 4 / 3
a d g j
b e h k
c f i l

可以看到內容是方向是反的。

如果要按照本來的習慣使用的話，一個方法就是改用 std::layout_left：

std::mdspan<char, std::extents<size_t, 4, 3>, std::layout_left> matrix(aData.data());

否則就是要把 X / Y 的定義反過來、也就是把第一個 extent 當作 Y、第二個 extent 當成 X 了～

這部分基本上有點偏向於習慣的問題，要使用的話最好還是確認一下是不是和自己預期的一樣了。（OpenCV 的 cv::Mat 或是 Eigen 的 Matrix 應該都和 mdspan 是一樣的形式？）