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] == 6mdspan 的模板参数
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 | 行优先 | 最右维度步长为 1 | C/C++ |
| layout_left | 列优先 | 最左维度步长为 1 | Fortran/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 库互操作。