array-Klasse
Stellt einen Datencontainer dar, mit dem Daten auf eine Zugriffstaste verschoben werden.
Syntax
template <typename value_type, int _Rank>
friend class array;
Parameter
value_type
Der Elementtyp der Daten.
_Rank
Der Rang des Arrays.
Member
Öffentliche Konstruktoren
| Name | Beschreibung |
|---|---|
| Arraykonstruktor | Initialisiert eine neue Instanz der array-Klasse. |
| ~array Destructor | Zerstört das array-Objekt. |
Öffentliche Methoden
| Name | Beschreibung |
|---|---|
| copy_to | Kopiert den Inhalt des array-Objekts in ein anderes array-Objekt. |
| data | Gibt einen Zeiger auf die Rohdaten des array-Objekts zurück. |
| get_accelerator_view | Gibt das accelerator_view -Objekt zurück, das die Position darstellt, an der das Array zugeordnet ist. Auf diese Eigenschaft kann nur auf der CPU zugegriffen werden. |
| get_associated_accelerator_view | Ruft das zweite accelerator_view-Objekt ab, das als Parameter übergeben wird, wenn ein Stagingkonstruktor aufgerufen wird, um das array Objekt zu instanziieren. |
| get_cpu_access_type | Gibt den access_type des Arrays zurück. Auf diese Methode kann nur auf der CPU zugegriffen werden. |
| get_extent | Gibt das Umfangsobjekt des Arrays zurück. |
| reinterpret_as | Gibt ein eindimensionales Array zurück, das alle Elemente im array-Objekt enthält. |
| section | Gibt einen Unterabschnitt des array-Objekts zurück, das sich am angegebenen Ursprung befindet und optional den angegebenen Wertebereich hat. |
| view_as | Gibt ein array_view -Objekt zurück, das aus dem array Objekt erstellt wird. |
Öffentliche Operatoren
| Name | Beschreibung |
|---|---|
operator std::vector<value_type> |
Wird copy(*this, vector) verwendet, um das Array implizit in ein std::vector -Objekt zu konvertieren. |
| operator() | Gibt den Elementwert zurück, der von den Parametern angegeben wird. |
| operator[] | Gibt das Element am angegebenen Index zurück. |
| operator= | Kopiert den Inhalt des angegebenen array-Objekts in dieses Objekt. |
Öffentliche Konstanten
| Name | Beschreibung |
|---|---|
| rank-Konstante | Speichert den Rang des Arrays. |
Öffentliche Datenmember
| Name | Beschreibung |
|---|---|
| accelerator_view | Ruft das accelerator_view -Objekt, das die Position darstellt, an der das Array zugeordnet ist. Auf diese Eigenschaft kann nur auf der CPU zugegriffen werden. |
| associated_accelerator_view | Ruft das zweite accelerator_view-Objekt ab, das als Parameter übergeben wird, wenn ein Stagingkonstruktor aufgerufen wird, um das array Objekt zu instanziieren. |
| cpu_access_type | Ruft die access_type , die angibt, wie die CPU auf den Speicher des Arrays zugreifen kann. |
| extent | Ruft den Wertebereich ab, der die Form des Arrays definiert. |
Hinweise
Der Typ array<T,N> stellt ein dichtes und normales (nicht getaggtes) Ndimensionales Array dar, das sich an einer bestimmten Position befindet, z. B. eine Zugriffstaste oder die CPU. Der Datentyp der Elemente im Array ist T. Der Typ muss mit der Zielzugriffstaste kompatibel ist. Obwohl der Rang, N, des Arrays statisch ermittelt und Teil des Typs ist, wird der Wertebereich des Arrays durch die Laufzeit bestimmt und durch Verwendung der extent<N>-Klasse ausgedrückt.
Ein Array kann eine beliebige Anzahl Dimensionen haben, obwohl einige Funktionen für array-Objekte mit dem Rang eins, zwei und drei spezialisiert ist. Wenn Sie das Dimensionsargument weglassen, ist der Standardwert 1.
Arraydaten grenzen im Arbeitsspeicher aneinander. Elemente, die sich in der unwichtigsten Dimension um eins unterscheiden, grenzen im Arbeitsspeicher aneinander.
Arrays werden logisch als Werttypen betrachtet, da beim Kopieren eines Arrays in ein anderes eine tiefe Kopie ausgeführt wird. Zwei Arrays zeigen nie auf die gleichen Daten.
Der array<T,N>-Typ wird in verschiedenen Szenarien verwendet:
Als Datencontainer, der in Berechnungen auf einer Zugriffstaste verwendet werden kann.
Als Datencontainer zum Vorhalten von Arbeitsspeicher auf der Host-CPU (die zum Kopieren in und von anderen Arrays verwendet werden kann).
Als Stagingobjekt, um in Kopien vom Host zum Gerät als schneller Vermittler zu fungieren.
Vererbungshierarchie
array
Anforderungen
Header: amp.h
Namespace: Parallelität
~Array
Zerstört das array-Objekt.
~array() restrict(cpu);
accelerator_view
Ruft das accelerator_view -Objekt, das die Position darstellt, an der das Array zugeordnet ist. Auf diese Eigenschaft kann nur auf der CPU zugegriffen werden.
__declspec(property(get= get_accelerator_view)) Concurrency::accelerator_view accelerator_view;
array
Initialisiert eine neue Instanz der Arrayklasse. Für "array<T,N>" ist kein Standardkonstruktor vorhanden. Alle Konstruktoren werden nur auf der CPU ausgeführt. Sie können nicht auf einem Direct3D-Ziel ausgeführt werden.
explicit array(
const Concurrency::extent<_Rank>& _Extent) restrict(cpu);
explicit array(
int _E0) restrict(cpu);
explicit array(
int _E0,
int _E1) restrict(cpu);
explicit array(
int _E0,
int _E1,
int _E2) restrict(cpu);
array(
const Concurrency::extent<_Rank>& _Extent,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
array(
int _E0,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
array(
int _E0,
int _E1,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
array(
int _E0,
int _E1,
int _E2,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
array(
const Concurrency::extent<_Rank>& _Extent,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
array(
int _E0,
accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
array(
int _E0,
int _E1,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
array(
int _E0,
int _E1,
int _E2,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
template <typename _InputIterator>
array(
const Concurrency::extent<_Rank>& _Extent,
_InputIterator _Src_first,
_InputIterator _Src_last) restrict(cpu);
template <typename _InputIterator>
array(
const Concurrency::extent<_Rank>& _Extent,
_InputIterator _Src_first) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
_InputIterator _Src_first,
_InputIterator _Src_last) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
_InputIterator _Src_first) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1,
_InputIterator _Src_first,
_InputIterator _Src_last) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1,
_InputIterator _Src_first) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1,
int _E2,
_InputIterator _Src_first,
_InputIterator _Src_last) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1,
int _E2,
_InputIterator _Src_first) restrict(cpu);
template <typename _InputIterator>
array(
const Concurrency::extent<_Rank>& _Extent,
_InputIterator _Src_first,
_InputIterator _Src_last,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
template <typename _InputIterator>
array(
const Concurrency::extent<_Rank>& _Extent,
_InputIterator _Src_first,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
_InputIterator _Src_first,
_InputIterator _Src_last,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
_InputIterator _Src_first,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1,
_InputIterator _Src_first,
_InputIterator _Src_last,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1,
_InputIterator _Src_first,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1,
int _E2,
_InputIterator _Src_first,
_InputIterator _Src_last,
Concurrency::accelerator_view _Av,
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1,
int _E2,
_InputIterator _Src_first,
Concurrency::accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
template <typename _InputIterator>
array(
const Concurrency::extent<_Rank>& _Extent,
_InputIterator _Src_first,
_InputIterator _Src_last,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
template <typename _InputIterator>
array(
const Concurrency::extent<_Rank>& _Extent,
_InputIterator _Src_first,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
_InputIterator _Src_first,
_InputIterator _Src_last,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
template <typename _InputIterator>
array(
int _E0, _InputIterator _Src_first,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1, _InputIterator _Src_first, _InputIterator _Src_last,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1, _InputIterator _Src_first,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1,
int _E2, _InputIterator _Src_first, _InputIterator _Src_last,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
template <typename _InputIterator>
array(
int _E0,
int _E1,
int _E2, _InputIterator _Src_first,
Concurrency::accelerator_view _Av,
Concurrency::accelerator_view _Associated_Av) restrict(cpu);
explicit array(
const array_view<const value_type, _Rank>& _Src) restrict(cpu);
array(
const array_view<const value_type, _Rank>& _Src,
accelerator_view _Av
access_type _Cpu_access_type = access_type_auto) restrict(cpu);
array(
const array_view<const value_type, _Rank>& _Src,
accelerator_view _Av,
accelerator_view _Associated_Av) restrict(cpu);
array(const array& _Other) restrict(cpu);
array(array&& _Other) restrict(cpu);
Parameter
_Associated_Av
Ein accelerator_view-Objekt, das den bevorzugten Zielort des Arrays angibt.
_Av
Ein accelerator_view-Objekt , das die Position des Arrays angibt.
_Cpu_access_type
Die gewünschte access_type für das Array auf der CPU. Dieser Parameter hat den Standardwert access_type_auto und überlässt die Bestimmung des CPU- access_type-Objekts der Laufzeit. Das tatsächliche CPU-access_type-Objekt für das Array kann mithilfe der get_cpu_access_type-Methode abgefragt werden.
_Umfang
Der Umfang in jeder Dimension des Arrays.
_E0
Die wichtigste Komponente des Umfangs dieses Abschnitts.
_E1
Die zweitwichtigste Komponente des Umfangs dieses Abschnitts.
_E2
Die unwichtigste Komponente des Umfangs dieses Abschnitts.
_Inputiterator
Der Typ des Eingabeiterators.
_Src
Das zu kopierende Objekt.
_Src_first
Ein Anfangsiterator in den Quellcontainer.
_Src_last
Ein Endeiterator in den Quellcontainer.
_Other
Andere Datenquelle.
_Rank
Der Rang des Abschnitts.
value_type
Der Datentyp der Elemente, die kopiert werden.
associated_accelerator_view
Ruft das zweite accelerator_view-Objekt ab, das als Parameter übergeben wird, wenn ein Stagingkonstruktor aufgerufen wird, um das array Objekt zu instanziieren.
__declspec(property(get= get_associated_accelerator_view)) Concurrency::accelerator_view associated_accelerator_view;
copy_to
Kopiert den Inhalt des Inhalts array in eine andere array.
void copy_to(
array<value_type, _Rank>& _Dest) const ;
void copy_to(
array_view<value_type, _Rank>& _Dest) const ;
Parameter
_Dest
Das array_view Objekt, in das kopiert werden soll.
cpu_access_type
Ruft das für dieses Array zulässige access_type-Objekt für die CPU ab.
__declspec(property(get= get_cpu_access_type)) access_type cpu_access_type;
data
Gibt einen Zeiger auf die Rohdaten des array-Objekts zurück.
value_type* data() restrict(amp, cpu);
const value_type* data() const restrict(amp, cpu);
Rückgabewert
Ein Zeiger auf die Rohdaten des array-Objekts.
extent
Ruft das Umfangsobjekt ab, das die Form der .array
__declspec(property(get= get_extent)) Concurrency::extent<_Rank> extent;
get_accelerator_view
Gibt das accelerator_view -Objekt zurück, das die Position darstellt, an der das array Objekt zugeordnet ist. Auf diese Eigenschaft kann nur auf der CPU zugegriffen werden.
Concurrency::accelerator_view get_accelerator_view() const;
Rückgabewert
Das accelerator_view Objekt, das die Position darstellt, an der das array Objekt zugeordnet ist.
get_associated_accelerator_view
Ruft das zweite accelerator_view-Objekt ab, das als Parameter übergeben wird, wenn ein Stagingkonstruktor aufgerufen wird, um das array Objekt zu instanziieren.
Concurrency::accelerator_view get_associated_accelerator_view() const ;
Rückgabewert
Das zweite accelerator_view-Objekt , das an den Stagingkonstruktor übergeben wurde.
get_cpu_access_type
Gibt das CPU-access_type-Objekt zurück, das für dieses Array zulässig ist.
access_type get_cpu_access_type() const restrict(cpu);
Rückgabewert
get_extent
Gibt das Umfangsobjekt der array.
Concurrency::extent<_Rank> get_extent() const restrict(amp,cpu);
Rückgabewert
Das extent-Objekt von array.
operator std::vector<value_type>
Wird copy(*this, vector) verwendet, um das Array implizit in ein std::vector -Objekt zu konvertieren.
operator std::vector<value_type>() const restrict(cpu);
Parameter
value_type
Der Datentyp der Elemente des Vektors.
Rückgabewert
Ein Objekt des Typs vector<T>, das eine Kopie der Daten im Array enthält.
Operator()
Gibt den Elementwert zurück, der von den Parametern angegeben wird.
value_type& operator() (const index<_Rank>& _Index) restrict(amp,cpu);
const value_type& operator() (const index<_Rank>& _Index) cons t restrict(amp,cpu);
value_type& operator() (int _I0, int _I1) restrict(amp,cpu);
const value_type& operator() (int _I0, int _I1) const restrict(amp,cpu) ;
value_type& operator() (int _I0, int _I1, int _I2) restrict(amp,cpu);
const value_type& operator() (int _I0, int _I1, int _I2) const restrict(amp,cpu);
typename details::_Projection_result_type<value_type,_Rank>::_Result_type operator()(int _I) restrict(amp,cpu);
typename details::_Projection_result_type<value_type,_Rank>::_Const_result_type operator()(int _I) const restrict(amp,cpu);
Parameter
_Index
Der Speicherort des Elements.
_I0
Die wichtigste Komponente des Ursprungs dieses Abschnitts.
_I1
Die zweitwichtigste Komponente des Ursprungs dieses Abschnitts.
_I2
Die unwichtigste Komponente des Ursprungs dieses Abschnitts.
_I
Der Speicherort des Elements.
Rückgabewert
Der Elementwert, der von den Parametern angegeben wird.
operator[]
Gibt das Element am angegebenen Index zurück.
value_type& operator[](const index<_Rank>& _Index) restrict(amp,cpu);
const value_type& operator[]
(const index<_Rank>& _Index) const restrict(amp,cpu);
typename details::_Projection_result_type<value_type,_Rank>::_Result_type operator[](int _i) restrict(amp,cpu);
typename details::_Projection_result_type<value_type,_Rank>::_Const_result_type operator[](int _i) const restrict(amp,cpu);
Parameter
_Index
Der Index.
_I
Der Index.
Rückgabewert
Das Element am angegebenen Index.
operator =
Kopiert den Inhalt des angegebenen array Objekts.
array& operator= (const array& _Other) restrict(cpu);
array& operator= (array&& _Other) restrict(cpu);
array& operator= (
const array_view<const value_type, _Rank>& _Src) restrict(cpu);
Parameter
_Other
Das array-Objekt, aus dem kopiert werden soll.
_Src
Das array-Objekt, aus dem kopiert werden soll.
Rückgabewert
Ein Verweis auf das array-Objekt.
rank
Speichert den Rang der array.
static const int rank = _Rank;
reinterpret_as
Interpretiert das Array über eine eindimensionale array_view neu, die optional einen anderen Werttyp als das Quellarray aufweisen kann.
Syntax
template <typename _Value_type2>
array_view<_Value_type2,1> reinterpret_as() restrict(amp,cpu);
template <typename _Value_type2>
array_view<const _Value_type2, 1> reinterpret_as() const restrict(amp,cpu);
Parameter
_Value_type2
Der Datentyp der zurückgegebenen Daten.
Rückgabewert
Ein array_view- oder const-array_view-Objekt, das auf dem Array basiert, wobei der Elementtyp von T auf ElementType neu interpretiert wird und der Rang von N auf 1 reduziert wurde.
Hinweise
Manchmal ist es hilfreich, ein mehrdimensionales Array so anzuzeigen, als wäre es ein lineares, eindimensionales Array, möglicherweise mit einem anderen Werttyp als das Quellarray. Sie können dazu diese Methode verwenden. Achtung : Das Erneute Interpretieren eines Arrayobjekts mithilfe eines anderen Werttyps ist ein potenziell unsicherer Vorgang. Es empfiehlt sich, diese Funktion mit Bedacht zu verwenden.
Der folgende Code gibt ein Beispiel.
struct RGB { float r; float g; float b; };
array<RGB,3> a = ...;
array_view<float,1> v = a.reinterpret_as<float>();
assert(v.extent == 3*a.extent);
section
Gibt einen Unterabschnitt des array-Objekts zurück, das sich am angegebenen Ursprung befindet und optional den angegebenen Wertebereich hat.
array_view<value_type,_Rank> section(
const Concurrency::index<_Rank>& _Section_origin,
const Concurrency::extent<_Rank>& _Section_extent) restrict(amp,cpu);
array_view<const value_type,_Rank> section(
const Concurrency::index<_Rank>& _Section_origin,
const Concurrency::extent<_Rank>& _Section_extent) const restrict(amp,cpu);
array_view<value_type,_Rank> section(
const Concurrency::extent<_Rank>& _Ext) restrict(amp,cpu);
array_view<const value_type,_Rank> section(
const Concurrency::extent<_Rank>& _Ext) const restrict(amp,cpu);
array_view<value_type,_Rank> section(
const index<_Rank>& _Idx) restrict(amp,cpu);
array_view<const value_type,_Rank> section(
const index<_Rank>& _Idx) const restrict(amp,cpu);
array_view<value_type,1> section(
int _I0,
int _E0) restrict(amp,cpu);
array_view<const value_type,1> section(
int _I0,
int _E0) const restrict(amp,cpu);
array_view<value_type,2> section(
int _I0,
int _I1,
int _E0,
int _E1) restrict(amp,cpu);
array_view<const value_type,2> section(
int _I0,
int _I1,
int _E0,
int _E1) const restrict(amp,cpu);
array_view<value_type,3> section(
int _I0,
int _I1,
int _I2,
int _E0,
int _E1,
int _E2) restrict(amp,cpu);
array_view<const value_type,3> section(
int _I0,
int _I1,
int _I2,
int _E0,
int _E1,
int _E2) const restrict(amp,cpu);
Parameter
_E0
Die wichtigste Komponente des Umfangs dieses Abschnitts.
_E1
Die zweitwichtigste Komponente des Umfangs dieses Abschnitts.
_E2
Die unwichtigste Komponente des Umfangs dieses Abschnitts.
_Extern
Das Umfangsobjekt , das den Umfang des Abschnitts angibt. Der Ursprung ist 0.
_Idx
Das Indexobjekt , das die Position des Ursprungs angibt. Der Unterabschnitt entspricht dem Rest des Umfangs.
_I0
Die wichtigste Komponente des Ursprungs dieses Abschnitts.
_I1
Die zweitwichtigste Komponente des Ursprungs dieses Abschnitts.
_I2
Die unwichtigste Komponente des Ursprungs dieses Abschnitts.
_Rank
Der Rang des Abschnitts.
_Section_extent
Das Umfangsobjekt , das den Umfang des Abschnitts angibt.
_Section_origin
Das Indexobjekt , das die Position des Ursprungs angibt.
value_type
Der Datentyp der Elemente, die kopiert werden.
Rückgabewert
Gibt einen Unterabschnitt des array-Objekts zurück, das sich am angegebenen Ursprung befindet und optional den angegebenen Wertebereich hat. Wenn nur das index-Objekt angegeben wird, enthält der Unterabschnitt alle Elemente im zugeordneten Raster, deren Indizes größer sind als die Indizes der Elemente im index-Objekt.
view_as
Interpretiert dieses Array als array_view einer anderen Rangfolge neu.
template <int _New_rank>
array_view<value_type,_New_rank> view_as(
const Concurrency::extent<_New_rank>& _View_extent) restrict(amp,cpu);
template <int _New_rank>
array_view<const value_type,_New_rank> view_as(
const Concurrency::extent<_New_rank>& _View_extent) const restrict(amp,cpu);
Parameter
_New_rank
Der Rang des extent-Objekts wurde als Parameter übergeben.
_View_extent
Das Ausmaß, in dem das neue array_view-Objekt erstellt wird.
value_type
Der Datentyp der Elemente sowohl im ursprünglichen array Objekt als auch im zurückgegebenen array_view Objekt.
Rückgabewert
Das array_view-Objekt , das erstellt wird.
Siehe auch
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für