std::mdspan

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de contenedores

De secuencias

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Asociativos

set

multiset

map

multimap

Asociativos no ordenados

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptadores

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Vistas

span (C++20)

mdspan (C++23)

Tablas

Invalidación de iteradores

Tabla de funciones miembro

Tabla de funciones no miembro

 

std::mdspan

Funciones miembro mdspan::mdspan mdspan::operator= Acceso a elementos mdspan::operator[] Observadores mdspan::rank mdspan::rank_dynamic mdspan::static_extent mdspan::extent mdspan::size mdspan::empty mdspan::stride mdspan::extents mdspan::data_handle mdspan::mapping mdspan::accessor mdspan::is_uniquemdspan::is_exhaustivemdspan::is_stridedmdspan::is_always_uniquemdspan::is_always_exhaustivemdspan::is_always_strided

Funciones no miembro swap(std::mdspan) Subvistas submdspan (C++26) submdspan_extents (C++26) Tipos auxiliares y plantillas extentsdextents dims (C++26) default_accessor aligned_accessor (C++26) Políticas de mapeo de diseño layout_left layout_right layout_stride layout_left_padded (C++26) layout_right_padded (C++26) Auxiliares de subvistas full_extent (C++26) strided_slice (C++26) submdspan_mapping_result (C++26) Guías de deducción

 

<tbody> </tbody>

Definido en el archivo de encabezado <mdspan>
template< class T, class Extents, class LayoutPolicy = std::layout_right, class AccessorPolicy = std::default_accessor<T> > class mdspan;		(desde C++23)

See More

std::mdspan es una vista de una secuencia contigua de objetos que la reinterpreta como un array multidimensional.

Cada especialización MDS de mdspan modela copyable y satisface:

• std::is_nothrow_move_constructible_v<MDS> es true,
• std::is_nothrow_move_assignable_v<MDS> es true, y
• std::is_nothrow_swappable_v<MDS> es true.

Una especialización de mdspan es un tipo TrivialmenteCopiable si su accessor_type, mapping_type y data_handle_type son tipos TrivialmenteCopiable.

Parámetros de plantilla

T	-	Tipo de elemento; un tipo objeto completo que no es ni un tipo clase abstracta ni un tipo array.
Extents	-	Especifica el número de dimensiones, sus tamaños y cuáles se conocen en el momento de la compilación. Debe ser una especialización de std::extents.
LayoutPolicy	-	Especifica cómo convertir un índice multidimensional a un índice 1D subyacente (array 3D de columna principal, array 2D triangular simétrica, etc.)).
AccessorPolicy	-	Especifica cómo convertir el índice 1D subyacente en una referencia a T. Debe satisfacer la restricción de que std::is_same_v<T, typename AccessorPolicy​::​element_type> es true.

Tipos miembro

Tipo miembro	Definición
extents_type	Extents
layout_type	LayoutPolicy
accessor_type	AccessorPolicy
mapping_type	LayoutPolicy::mapping<Extents>
element_type	T
value_type	std::remove_cv_t<T>
index_type	Extents::index_type
size_type	Extents::size_type
rank_type	Extents::rank_type
data_handle_type	AccessorPolicy::data_handle_type
reference	AccessorPolicy::reference

Datos miembro

Nombre	Definición
acc_ (private)	El descriptor de acceso. (objeto miembro solo de exposición*)
map_ (private)	El mapeo de diseño. (objeto miembro solo de exposición*)
ptr_ (private)	El identificador de datos subyacente. (objeto miembro solo de exposición*)

Funciones miembro

(constructor)	Construye un objeto de tipo mdspan. (función miembro pública)
operator=	Asigna un objeto de tipo mdspan. (función miembro pública)
Acceso a elementos
operator[]	Accede a un elemento en el índice multidimensional especificado. (función miembro pública)
Observadores
rank [estático]	Devuelve el rango de un mdspan. (función miembro estática pública)
rank_dynamic [estático]	Devuelve el rango dinámico de un mdspan. (función miembro estática pública)
static_extent [estático]	Devuelve el tamaño de extensión estático de un mdspan en un índice de rango dado. (función miembro estática pública)
extent	Devuelve la extensión de un mdspan en un índice de rango dado. (función miembro pública)
size	Devuelve el tamaño del espacio del índice multidimensional. (función miembro pública)
empty	Comprueba si el tamaño del espacio de índice es cero. (función miembro pública)
stride	Obtiene el avance a lo largo de la dimensión especificada. (función miembro pública)
extents	Obtiene el objeto de tipo std::extents. (función miembro pública)
data_handle	Obtiene el puntero a la secuencia 1D subyacente. (función miembro pública)
mapping	Obtiene el objeto de mapeo. (función miembro pública)
accessor	Obtiene el objeto de política del accessor. (función miembro pública)
is_unique	Determina si el mapeo de este mdspan es único (cada combinación de índices se asigna a un elemento subyacente diferente). (función miembro pública)
is_exhaustive	Determina si el mapeo de este mdspan es exhaustivo (se puede acceder a cada elemento subyacente con alguna combinación de índices). (función miembro pública)
is_strided	Determina si se avanza el mapeo de este mdspan (en cada dimensión, al incrementar un índice se salta el mismo número de elementos subyacentes cada vez). (función miembro pública)
is_always_unique [estático]	Determina si el mapeo de diseño de este mdspan es siempre único. (función miembro estática pública)
is_always_exhaustive [estático]	Determina si el mapeo de diseño de este mdspan es siempre exhaustivo. (función miembro estática pública)
is_always_strided [estático]	Determina si el mapeo de diseño de este mdspan siempre se avanza. (función miembro estática pública)

Funciones no miembro

std::swap(std::mdspan) (C++23)	Especializa el algoritmo std::swap para mdspan. (plantilla de función)
Subvistas
submdspan (C++26)	Devuelve una vista de un subconjunto de un mdspan existente. (plantilla de función)
submdspan_extents (C++26)	Crea nuevas extensiones a partir de las extensiones existentes y los especificadores de sección. (plantilla de función)

Tipos auxiliares y plantillas

extents (C++23)	Un descriptor de un espacio de índice multidimensional de algún rango. (plantilla de clase)
dextents (C++23)	Plantilla de alias conveniente para un std::extents totalmente dinámico. (plantilla de alias)
default_accessor (C++23)	Un tipo para acceso indexado a elementos de mdspan. (plantilla de clase)
aligned_accessor (C++26)	Un tipo para el acceso alineado a los elementos de mdspan. (plantilla de clase)
Políticas de mapeo de diseño
layout_left (C++23)	Política de mapeo de diseño de array multidimensional de columnas principales; la extensión más a la izquierda tiene avance 1. (clase)
layout_right (C++23)	Política de mapeo de diseño de array multidimensional de fila principal; la extensión más a la derecha tiene avance 1. (clase)
layout_stride (C++23)	Una política de mapeo de diseño con avances definidos por el usuario. (clase)
layout_left_padded (C++26)	Política de mapeo de diseño de columna principal con paso de relleno que puede ser mayor o igual que la extensión más a la izquierda. (plantilla de clase)
layout_right_padded (C++26)	Política de mapeo de diseño de fila principal con paso de relleno que puede ser mayor o igual que la extensión más a la derecha. (plantilla de clase)
Auxiliares de subvistas
full_extentfull_extent_t (C++26)	Una etiqueta especificadora de sectores que describe el rango completo de índices en la extensión especificada. (tag)
strided_slice (C++26)	Un especificador de sección que representa un conjunto de índices espaciados regularmente como lo indica un desplazamiento, una extensión y un avance. (plantilla de clase)
submdspan_mapping_result (C++26)	Un tipo de retorno de las sobrecargas de submdspan_mapping. (plantilla de clase)

Guías de deducción

Notas

Macro de prueba de característica
__cpp_lib_mdspan	202207L	(C++23)	std::mdspan
__cpp_lib_submdspan	202306L	(C++26)	std::submdspan
	202403L	(C++26)	std::mdspan padded layouts
__cpp_lib_aligned_accessor	202411L	(C++26)	std::aligned_accessor

Ejemplo

Se puede obtener una vista previa en Compiler Explorer.

Ejecuta este código

#include <cstddef>
#include <mdspan>
#include <print>
#include <vector>

int main()
{
    std::vector v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

    // Ver datos como memoria contigua que representa 2 filas de 6 entradas cada una
    auto ms2 = std::mdspan(v.data(), 2, 6);
    // Ver los mismos datos como un array 3D 2 x 3 x 2
    auto ms3 = std::mdspan(v.data(), 2, 3, 2);

    // Escribir datos usando la vista 2D
    for (std::size_t i = 0; i != ms2.extent(0); i++)
        for (std::size_t j = 0; j != ms2.extent(1); j++)
            ms2[i, j] = i * 1000 + j;

    // Volver a leer usando la vista 3D
    for (std::size_t i = 0; i != ms3.extent(0); i++)
    {
        std::println("sección @ i = {}", i);
        for (std::size_t j = 0; j != ms3.extent(1); j++)
        {
            for (std::size_t k = 0; k != ms3.extent(2); k++)
                std::print("{} ", ms3[i, j, k]);
            std::println("");
        }
    }
}

Salida:

sección @ i = 0
0 1
2 3
4 5
sección @ i = 1
1000 1001
1002 1003
1004 1005

Véase también

span (C++20)	Una vista que no es dueña sobre una secuencia contigua de objetos. (plantilla de clase)
valarray	arrays numéricos, máscaras de arrays y secciones de array. (plantilla de clase)