std::mdspan

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::mdspan

Memberfunktionen mdspan::mdspan mdspan::operator= Elementzugriff mdspan::operator[] Observer 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

Nicht-Member-Funktionen swap(std::mdspan) Unteransichten (Subviews) submdspan (C++26) submdspan_extents (C++26) Hilfstypen und Vorlagen extentsdextents dims (C++26) default_accessor aligned_accessor (C++26) Layout-Mapping-Richtlinien layout_left layout_right layout_stride layout_left_padded (C++26) layout_right_padded (C++26) Hilfstypen für Unteransichten full_extent (C++26) strided_slice (C++26) submdspan_mapping_result (C++26) Deduction Guides

 

Definiert in Header <mdspan>
template<     class T,     class Extents,     class LayoutPolicy = std::layout_right,     class AccessorPolicy = std::default_accessor<T> > class mdspan;		(seit C++23)

std::mdspan ist eine multidimensionale Array-Ansicht, die einen multidimensionalen Index auf ein Element des Arrays abbildet. Die Abbildungs- und Elementzugriffsrichtlinien sind konfigurierbar, und das zugrunde liegende Array muss nicht zusammenhängend sein oder überhaupt im Speicher existieren.

Jede Spezialisierung MDS von mdspan modelliert copyable und erfüllt

• std::is_nothrow_move_constructible_v<MDS> ist true,
• std::is_nothrow_move_assignable_v<MDS> ist true, und
• std::is_nothrow_swappable_v<MDS> ist true.

Eine Spezialisierung von mdspan ist ein TriviallyCopyable-Typ, wenn seine accessor_type, mapping_type und data_handle_type TriviallyCopyable-Typen sind.

Template-Parameter

T	-	Elementtyp; ein vollständiger Objekttyp, der weder ein abstrakter Klassentyp noch ein Array-Typ ist.
Extents	-	gibt die Anzahl der Dimensionen, ihre Größen und welche zur Kompilierzeit bekannt sind, an. Muss eine Spezialisierung von std::extents sein.
LayoutPolicy	-	gibt an, wie ein multidimensionaler Index in einen eindimensionalen Basisindex umgewandelt wird (spaltenmajorisierte 3D-Array, symmetrische dreieckige 2D-Matrix usw.). Muss die Anforderungen von LayoutMappingPolicy erfüllen.
AccessorPolicy	-	gibt an, wie ein eindimensionaler Basisindex in eine Referenz auf T umgewandelt wird. Muss die Einschränkung erfüllen, dass std::is_same_v<T, typename AccessorPolicy​::​element_type> true ist. Muss die Anforderungen von AccessorPolicy erfüllen.

Member Types

Mitglied	Definition
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
Referenz	AccessorPolicy::reference

Datenmember

Mitglied	Beschreibung
accessor_type acc_ (private)	der Accessor ((exposition-only member object*)
mapping_type map_ (private)	das Layout-Mapping ((exposition-only member object*)
data_handle_type ptr_ (private)	das zugrunde liegende Daten-Handle ((exposition-only member object*)

Member-Funktionen

(Konstruktor)	konstruiert ein mdspan (public member function)
operator=	weist ein mdspan zu (public member function)
Elementzugriff
operator[]	greift auf ein Element am angegebenen multidimensionalen Index zu (public member function)
Observer
rank [static]	gibt den Rang eines mdspan zurück (public static member function)
rank_dynamic [static]	gibt den dynamischen Rang eines mdspan zurück (public static member function)
static_extent [static]	gibt die statische Extentgröße eines mdspan am gegebenen Rangindex zurück (public static member function)
extent	gibt die Extent eines mdspan am gegebenen Rangindex zurück (public member function)
size	gibt die Größe des multidimensionalen Indexraums zurück (public member function)
empty	prüft, ob die Größe des Indexraums null ist (public member function)
stride	erhält den Schritt entlang der angegebenen Dimension (public member function)
extents	erhält das Extents-Objekt (public member function)
data_handle	erhält den Zeiger auf die zugrunde liegende 1D-Sequenz (public member function)
mapping	erhält das Mapping-Objekt (public member function)
accessor	erhält das Accessor-Richtlinienobjekt (public member function)
is_unique	bestimmt, ob das Mapping dieses mdspan eindeutig ist (jede Indexkombination wird auf ein anderes zugrunde liegendes Element abgebildet) (public member function)
is_exhaustive	bestimmt, ob das Mapping dieses mdspan erschöpfend ist (jedes zugrunde liegende Element kann mit einer Indexkombination erreicht werden) (public member function)
is_strided	bestimmt, ob das Mapping dieses mdspan schrittweise ist (in jeder Dimension überspringt das Inkrementieren eines Index jedes Mal die gleiche Anzahl zugrunde liegender Elemente) (public member function)
is_always_unique [static]	bestimmt, ob das Layout-Mapping dieses mdspan immer eindeutig ist (public static member function)
is_always_exhaustive [static]	bestimmt, ob das Layout-Mapping dieses mdspan immer erschöpfend ist (public static member function)
is_always_strided [static]	bestimmt, ob das Layout-Mapping dieses mdspan immer schrittweise ist (public static member function)

Nicht-Member-Funktionen

std::swap(std::mdspan) (C++23)	spezialisiert den Algorithmus std::swap für mdspan (function template)
Unteransichten (Subviews)
submdspan (C++26)	gibt eine Ansicht eines Teils eines vorhandenen mdspan zurück (function template)
submdspan_extents (C++26)	erstellt neue Extents aus den vorhandenen Extents und Slice-Spezifikatoren (function template)

Hilfstypen und Vorlagen

extents (C++23)	ein Deskriptor eines multidimensionalen Indexraums eines bestimmten Rangs (class template)
dextentsdims (C++23)(C++26)	bequeme Alias-Vorlage für ein rein dynamisches std::extents (alias template)
default_accessor (C++23)	ein Typ für den indizierten Zugriff auf Elemente von mdspan (class template)
aligned_accessor (C++26)	ein Typ für den ausgerichteten Zugriff auf Elemente von mdspan (class template)
Layout-Mapping-Richtlinien
layout_left (C++23)	spaltenmajorisierte multidimensionale Array-Layout-Mapping-Richtlinie; die linkeste Extent hat einen Schritt von 1 (class)
layout_right (C++23)	zeilenmajorisierte multidimensionale Array-Layout-Mapping-Richtlinie; die rechteste Extent hat einen Schritt von 1 (class)
layout_stride (C++23)	eine Layout-Mapping-Richtlinie mit benutzerdefinierten Schritten (class)
layout_left_padded (C++26)	spaltenmajorisierte Layout-Mapping-Richtlinie mit einem Auffüllschritt, der größer oder gleich der linkesten Extent sein kann (class template)
layout_right_padded (C++26)	zeilenmajorisierte Layout-Mapping-Richtlinie mit einem Auffüllschritt, der größer oder gleich der rechtesten Extent sein kann (class template)
Hilfstypen für Unteransichten
full_extentfull_extent_t (C++26)	ein Slice-Spezifikator-Tag, der den vollen Bereich von Indizes in der angegebenen Extent beschreibt. (tag)
strided_slice (C++26)	ein Slice-Spezifikator, der eine Menge von regelmäßig beabstandeten Indizes repräsentiert, wie durch einen Offset, eine Extent und einen Schritt angegeben (class template)
submdspan_mapping_result (C++26)	ein Rückgabetyp der Überladungen von submdspan_mapping (class template)

Hinweise

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_mdspan	202207L	(C++23)	std::mdspan
__cpp_lib_submdspan	202306L	(C++26)	std::submdspan
	202403L	(C++26)	std::mdspan aufgefüllte Layouts
__cpp_lib_aligned_accessor	202411L	(C++26)	std::aligned_accessor

Beispiel

Kann auf Compiler Explorer in der Vorschau angezeigt werden.

Führen Sie diesen Code aus

#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("");
        }
    }
}

Ausgabe

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

Siehe auch

span (C++20)	eine nicht besitzende Ansicht über eine zusammenhängende Sequenz von Objekten (class template)
valarray	numerische Arrays, Array-Masken und Array-Slices (Klassenvorlage)