Freigeben über

array-Klasse

  • Artikel

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

~Anordnung

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

Concurrency-Namespace (C++ AMP)