std::mdspan 多维视图(C++23) ​

什么是 std::mdspan ​

std::mdspan 是 C++23 引入的多维非拥有数组视图,可以把一块一维连续内存解释为多维数组来访问。它是 std::span 的多维扩展——span 是一维视图,mdspan 是任意维度的视图。

cpp
#include <mdspan>

std::vector<int> data = {1, 2, 3, 4, 5, 6};
// 把一维数据看作 2x3 矩阵
std::mdspan<int, std::extents<size_t, 2, 3>> mat{data.data()};
// mat[0, 1] == 2, mat[1, 2] == 6

mdspan 的模板参数 ​

cpp
template<
    class T,                                       // 元素类型
    class Extents,                                 // 维度描述
    class LayoutPolicy = std::layout_right,        // 布局策略
    class AccessorPolicy = std::default_accessor<T> // 访问策略
>
class mdspan;
参数说明默认值
T元素类型—
Extents各维度的大小(静态或动态)—
LayoutPolicy行优先/列优先/自定义步长layout_right(行优先)
AccessorPolicy元素访问方式default_accessor<T>

基本示例 ​

cpp
#include <iostream>
#include <vector>
#include <array>
#include <mdspan>
#include <numeric>

// ============================
// 示例1:静态维度 mdspan
// ============================

void static_demo() {
    // 12 个元素的一维数据
    int data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

    // 解释为 3x4 矩阵(静态维度,编译期已知)
    std::mdspan<int, std::extents<size_t, 3, 4>> mat{data};

    std::cout << "3x4 矩阵:" << std::endl;
    for (size_t i = 0; i < mat.extent(0); i++) {
        for (size_t j = 0; j < mat.extent(1); j++) {
            std::cout << mat[i, j] << "\t";
        }
        std::cout << std::endl;
    }
    // 1  2  3  4
    // 5  6  7  8
    // 9  10 11 12
}

// ============================
// 示例2:动态维度 mdspan
// ============================

void dynamic_demo() {
    std::vector<int> data(20);
    std::iota(data.begin(), data.end(), 1);  // 1 到 20

    // 运行时指定维度
    size_t rows = 4, cols = 5;
    std::mdspan<int, std::dextents<size_t, 2>> mat{data.data(), rows, cols};

    std::cout << rows << "x" << cols << " 矩阵:" << std::endl;
    for (size_t i = 0; i < mat.extent(0); i++) {
        for (size_t j = 0; j < mat.extent(1); j++) {
            std::cout << mat[i, j] << "\t";
        }
        std::cout << std::endl;
    }

    // 基本属性
    std::cout << "rank: " << mat.rank() << std::endl;      // 2
    std::cout << "extent(0): " << mat.extent(0) << std::endl; // 4
    std::cout << "extent(1): " << mat.extent(1) << std::endl; // 5
    std::cout << "size: " << mat.size() << std::endl;        // 20
}

// ============================
// 示例3:混合静态和动态维度
// ============================

void mixed_demo() {
    std::vector<int> data(15);
    std::iota(data.begin(), data.end(), 0);

    // 行数动态,列数固定为 5
    std::mdspan<int, std::extents<size_t, std::dynamic_extent, 5>> mat{data.data(), 3};

    std::cout << "混合维度 " << mat.extent(0) << "x" << mat.extent(1) << ":" << std::endl;
    for (size_t i = 0; i < mat.extent(0); i++) {
        for (size_t j = 0; j < mat.extent(1); j++) {
            std::cout << mat[i, j] << "\t";
        }
        std::cout << std::endl;
    }
}

// ============================
// 示例4:layout_right vs layout_left
// ============================

void layout_demo() {
    int data[] = {0, 1, 2, 3, 4, 5};

    // layout_right(默认):行优先(C 风格)
    // 内存中: row0_col0, row0_col1, row0_col2, row1_col0, ...
    std::mdspan<int, std::dextents<size_t, 2>, std::layout_right> row_major{data, 2, 3};

    std::cout << "行优先(layout_right):" << std::endl;
    for (size_t i = 0; i < row_major.extent(0); i++) {
        for (size_t j = 0; j < row_major.extent(1); j++) {
            std::cout << row_major[i, j] << " ";
        }
        std::cout << std::endl;
    }
    // 0 1 2
    // 3 4 5

    // layout_left:列优先(Fortran 风格)
    // 内存中: row0_col0, row1_col0, row0_col1, row1_col1, ...
    std::mdspan<int, std::dextents<size_t, 2>, std::layout_left> col_major{data, 2, 3};

    std::cout << "列优先(layout_left):" << std::endl;
    for (size_t i = 0; i < col_major.extent(0); i++) {
        for (size_t j = 0; j < col_major.extent(1); j++) {
            std::cout << col_major[i, j] << " ";
        }
        std::cout << std::endl;
    }
    // 0 2 4
    // 1 3 5
}

// ============================
// 示例5:三维 mdspan
// ============================

void three_d_demo() {
    // 2x3x4 的三维数组
    std::vector<int> data(24);
    std::iota(data.begin(), data.end(), 0);

    std::mdspan<int, std::extents<size_t, 2, 3, 4>> cube{data.data()};

    std::cout << "3D mdspan (2x3x4):" << std::endl;
    for (size_t i = 0; i < cube.extent(0); i++) {
        std::cout << "层 " << i << ":" << std::endl;
        for (size_t j = 0; j < cube.extent(1); j++) {
            std::cout << "  ";
            for (size_t k = 0; k < cube.extent(2); k++) {
                std::cout << cube[i, j, k] << "\t";
            }
            std::cout << std::endl;
        }
    }
}

// ============================
// 示例6:mdspan 作为函数参数
// ============================

// 通用的矩阵打印函数
void print_matrix(std::mdspan<const int, std::dextents<size_t, 2>> mat) {
    for (size_t i = 0; i < mat.extent(0); i++) {
        for (size_t j = 0; j < mat.extent(1); j++) {
            std::cout << mat[i, j] << "\t";
        }
        std::cout << std::endl;
    }
}

// 矩阵转置
void transpose(std::mdspan<const int, std::dextents<size_t, 2>> src,
               std::mdspan<int, std::dextents<size_t, 2>> dst) {
    for (size_t i = 0; i < src.extent(0); i++) {
        for (size_t j = 0; j < src.extent(1); j++) {
            dst[j, i] = src[i, j];
        }
    }
}

void function_param_demo() {
    int data[] = {1, 2, 3, 4, 5, 6};
    std::mdspan<int, std::dextents<size_t, 2>> mat{data, 2, 3};

    std::cout << "原矩阵:" << std::endl;
    print_matrix(mat);

    // 转置
    std::vector<int> dst_data(6);
    std::mdspan<int, std::dextents<size_t, 2>> transposed{dst_data.data(), 3, 2};
    transpose(mat, transposed);

    std::cout << "转置后:" << std::endl;
    print_matrix(transposed);
}

// ============================
// 示例7:通过 mdspan 修改数据
// ============================

void modify_demo() {
    std::vector<int> data(9, 0);
    std::mdspan<int, std::extents<size_t, 3, 3>> mat{data.data()};

    // 设置单位矩阵
    for (size_t i = 0; i < 3; i++) {
        mat[i, i] = 1;
    }

    std::cout << "单位矩阵:" << std::endl;
    for (size_t i = 0; i < mat.extent(0); i++) {
        for (size_t j = 0; j < mat.extent(1); j++) {
            std::cout << mat[i, j] << " ";
        }
        std::cout << std::endl;
    }
}

int main() {
    std::cout << "=== 静态维度 ===" << std::endl;
    static_demo();

    std::cout << "\n=== 动态维度 ===" << std::endl;
    dynamic_demo();

    std::cout << "\n=== 混合维度 ===" << std::endl;
    mixed_demo();

    std::cout << "\n=== 布局策略 ===" << std::endl;
    layout_demo();

    std::cout << "\n=== 三维 ===" << std::endl;
    three_d_demo();

    std::cout << "\n=== 函数参数 ===" << std::endl;
    function_param_demo();

    std::cout << "\n=== 修改数据 ===" << std::endl;
    modify_demo();

    return 0;
}

维度描述方式 ​

方式类型说明
全静态extents<size_t, 3, 4>编译期确定 3x4
全动态dextents<size_t, 2>运行时确定二维大小
混合extents<size_t, dynamic_extent, 4>行数动态,列数固定 4

布局策略对比 ​

布局说明步长常见于
layout_right行优先最右维度步长为 1C/C++
layout_left列优先最左维度步长为 1Fortran/Matlab
layout_stride自定义步长每个维度独立步长子矩阵视图

适用场景 ​

  • 科学计算和线性代数(矩阵操作)
  • 图像处理(2D/3D 像素数据)
  • 数值模拟(多维网格)
  • 与 C/Fortran 库互操作(不同布局策略)
  • 替代手动的指针算术多维访问

常见问题 ​

mdspan 拥有数据吗?

不拥有。和 span 一样,mdspan 只是一个非拥有的视图,底层数据必须由其他对象管理。

mdspan 的多维下标语法是什么?

C++23 允许 mat[i, j] 的多维下标语法(多参数 operator[])。这比 mat(i, j) 或 mat[i][j] 更直观。

layout_right 和 layout_left 的性能区别?

取决于访问模式。按行遍历时 layout_right 更快(cache-friendly),按列遍历时 layout_left 更快。选择应匹配你的主要访问模式。

mdspan 支持切片(submdspan)吗?

C++26 将引入 std::submdspan,支持从 mdspan 中提取子视图。

注意事项 ​

  • mdspan 不拥有数据——注意底层内存的生命周期
  • 默认布局是 layout_right(行优先,C 风格)
  • 静态维度可以让编译器做更多优化
  • 多维下标用 mat[i, j] 而不是 mat[i][j]
  • mdspan 的 size() 返回所有维度乘积
  • C++26 将增加 submdspan 和 padded layout

编译器支持情况 ​

编译器std::mdspan最低版本
GCC支持14.0
Clang支持18.0(libc++)
MSVC支持19.34 (VS 2022 17.4)

总结 ​

std::mdspan 是 C++23 引入的多维数组视图,把一维连续内存解释为任意维度的数组来访问。它不拥有数据,只提供多维索引到一维偏移的映射。mdspan 支持静态维度、动态维度和混合维度,支持行优先(layout_right)和列优先(layout_left)两种布局策略。多维下标使用 C++23 的新语法 mat[i, j]。mdspan 特别适合科学计算、图像处理等需要多维数组的场景,也方便与使用不同布局的 C/Fortran 库互操作。