Namespaces
Variants

std:: mdspan

From cppreference.net
C++
Containers library
std::mdspan
Défini dans l'en-tête <mdspan>
template <

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

> class mdspan ;
(depuis C++23)

std::mdspan est une vue de tableau multidimensionnelle qui associe un index multidimensionnel à un élément du tableau. Les politiques de mappage et d'accès aux éléments sont configurables, et le tableau sous-jacent n'a pas besoin d'être contigu ni même d'exister en mémoire du tout.

Chaque spécialisation MDS de mdspan modélise copyable et satisfait :

Une spécialisation de mdspan est un type TriviallyCopyable si son accessor_type , son mapping_type et son data_handle_type sont des types TriviallyCopyable .

Table des matières

Paramètres du modèle

T - type d'élément ; un type d'objet complet qui n'est ni un type de classe abstraite ni un type de tableau.
Extents - spécifie le nombre de dimensions, leurs tailles, et celles connues à la compilation. Doit être une spécialisation de std::extents .
LayoutPolicy - spécifie comment convertir un index multidimensionnel en index 1D sous-jacent (tableau 3D en colonne-majeure, matrice triangulaire symétrique 2D, etc.). Doit satisfaire aux exigences de LayoutMappingPolicy .
AccessorPolicy - spécifie comment convertir un index 1D sous-jacent en une référence vers T. Doit satisfaire la contrainte que std:: is_same_v < T, typename AccessorPolicy​ :: ​element_type > est true . Doit satisfaire aux exigences de AccessorPolicy .

Types membres

Membre Définition
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

Membres de données

Membre Description
accessor_type acc_ (privé) l'accesseur
( objet membre d'exposition uniquement* )
mapping_type map_ (privé) le mapping de disposition
( objet membre d'exposition uniquement* )
data_handle_type ptr_ (privé) le handle de données sous-jacent
( objet membre d'exposition uniquement* )

Fonctions membres

construit un mdspan
(fonction membre publique)
assigne un mdspan
(fonction membre publique)
Accès aux éléments
accède à un élément à l'index multidimensionnel spécifié
(fonction membre publique)
Observateurs
[static]
retourne le rang d'un mdspan
(fonction membre statique publique)
[static]
retourne le rang dynamique d'un mdspan
(fonction membre statique publique)
[static]
retourne la taille d'étendue statique d'un mdspan à un index de rang donné
(fonction membre statique publique)
retourne l'étendue d'un mdspan à un index de rang donné
(fonction membre publique)
retourne la taille de l'espace d'index multidimensionnel
(fonction membre publique)
vérifie si la taille de l'espace d'index est zéro
(fonction membre publique)
obtient le pas le long de la dimension spécifiée
(fonction membre publique)
obtient l'objet d'étendues
(fonction membre publique)
obtient le pointeur vers la séquence 1D sous-jacente
(fonction membre publique)
obtient l'objet de mappage
(fonction membre publique)
obtient l'objet de politique d'accès
(fonction membre publique)
détermine si le mappage de ce mdspan est unique (chaque combinaison d'indices mappe vers un élément sous-jacent différent)
(fonction membre publique)
détermine si le mappage de ce mdspan est exhaustif (chaque élément sous-jacent peut être accédé avec une certaine combinaison d'indices)
(fonction membre publique)
détermine si le mappage de ce mdspan est à pas (dans chaque dimension, incrémenter un index saute par-dessus le même nombre d'éléments sous-jacents à chaque fois)
(fonction membre publique)
[static]
détermine si le mappage de mise en page de ce mdspan est toujours unique
(fonction membre statique publique)
[static]
détermine si le mappage de mise en page de ce mdspan est toujours exhaustif
(fonction membre statique publique)
[static]
détermine si le mappage de mise en page de ce mdspan est toujours à pas
(fonction membre statique publique)

Fonctions non membres

(C++23)
spécialise l'algorithme std::swap pour mdspan
(modèle de fonction)
Sous-vues
(C++26)
retourne une vue d'un sous-ensemble d'un mdspan existant
(modèle de fonction)
(C++26)
crée de nouvelles dimensions à partir des dimensions existantes et des spécificateurs de tranche
(modèle de fonction)

Types et modèles auxiliaires

(C++23)
un descripteur d'un espace d'index multidimensionnel d'un certain rang
(modèle de classe)
(C++23) (C++26)
alias de modèle pratique pour un std::extents entièrement dynamique
(modèle d'alias)
(C++23)
un type pour l'accès indexé aux éléments de mdspan
(modèle de classe)
(C++26)
un type pour l'accès aligné aux éléments de mdspan
(modèle de classe)
Politiques de mappage de disposition
(C++23)
politique de mappage de disposition de tableau multidimensionnel en colonne principale ; l'étendue la plus à gauche a un pas de 1
(classe)
(C++23)
politique de mappage de disposition de tableau multidimensionnel en ligne principale ; l'étendue la plus à droite a un pas de 1
(classe)
(C++23)
une politique de mappage de disposition avec des pas définis par l'utilisateur
(classe)
(C++26)
politique de mappage de disposition en colonne principale avec un pas de remplissage pouvant être supérieur ou égal à l'étendue la plus à gauche
(modèle de classe)
(C++26)
politique de mappage de disposition en ligne principale avec un pas de remplissage pouvant être supérieur ou égal à l'étendue la plus à droite
(modèle de classe)
Aides aux sous-vues
(C++26)
une étiquette de spécificateur de tranche décrivant la plage complète d'indices dans l'étendue spécifiée.
(étiquette)
(C++26)
un spécificateur de tranche représentant un ensemble d'indices régulièrement espacés comme indiqué par un décalage, une étendue et un pas
(modèle de classe)
(C++26)
un type de retour des surcharges de submdspan_mapping
(modèle de classe)

Guides de déduction

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_mdspan 202207L (C++23) std::mdspan
__cpp_lib_submdspan 202306L (C++26) std::submdspan
202403L (C++26) std::mdspan dispositions avec remplissage
__cpp_lib_aligned_accessor 202411L (C++26) std::aligned_accessor

Exemple

Peut être prévisualisé sur Compiler Explorer .

Exécuter ce code 
#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};
    // View data as contiguous memory representing 2 rows of 6 ints each
    auto ms2 = std::mdspan(v.data(), 2, 6);
    // View the same data as a 3D array 2 x 3 x 2
    auto ms3 = std::mdspan(v.data(), 2, 3, 2);
    // Write data using 2D view
    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;
    // Read back using 3D view
    for (std::size_t i = 0; i != ms3.extent(0); i++)
    {
        std::println("slice @ 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("");
        }
    }
}

Sortie : 

slice @ i = 0
0 1
2 3
4 5
slice @ i = 1
1000 1001
1002 1003
1004 1005

Voir aussi

(C++20)
une vue non propriétaire sur une séquence contiguë d'objets
(modèle de classe)
tableaux numériques, masques de tableau et tranches de tableau
(modèle de classe)