array 類別

發行項
08/04/2024

表示用來將數據移至加速器的數據容器。

語法

template <typename value_type, int _Rank>
friend class array;

參數

value_type
數據的元素類型。

_排
陣列的排名。

成員

公用建構函式

名稱	描述
array 建構函式	初始化 `array` 類別的新執行個體。
~array 解構函式	`array`終結物件。

公用方法

名稱	描述
copy_to	將陣列的內容複製到另一個數位。
data	傳回數位原始數據的指標。
get_accelerator_view	會傳回代表陣列配置位置的 accelerator_view 物件。此屬性只能在 CPU 上存取。
get_associated_accelerator_view	取得呼叫暫存建構函式來具`array`現化物件時，做為參數傳遞的第二個accelerator_view物件。
get_cpu_access_type	傳回數位的access_type 。這個方法只能在CPU上存取。
get_extent	傳回數位的範圍物件。
reinterpret_as	傳回一維陣列，其中包含物件中的所有 `array` 專案。
section	傳回位於指定原點之 `array` 物件的子區段，並選擇性地傳回具有指定範圍的子區段。
view_as	傳回從 `array` 物件建構的array_view物件。

公用運算子

名稱	描述
`operator std::vector<value_type>`	使用 `copy(*this, vector)` 以隱含方式將陣列轉換成 std：：vector 物件。
operator（）	傳回參數所指定的項目值。
operator[]	傳回位於指定索引處的專案。
operator=	將指定 `array` 之物件的內容複製到這個物件中。

公用常數

名稱	描述
rank 常數	儲存陣列的排名。

公用資料成員

名稱	描述
accelerator_view	取得accelerator_view物件，表示配置數位的位置。此屬性只能在 CPU 上存取。
associated_accelerator_view	取得呼叫暫存建構函式來具`array`現化物件時，做為參數傳遞的第二個accelerator_view物件。
cpu_access_type	取得access_type，表示CPU如何存取數位的記憶體。
extent	取得定義陣陣圖形的範圍。

備註

此類型 array<T,N> 代表位於特定位置的密集且一般（非不鋸齒） N 維陣列，例如加速器或 CPU。陣列中項目的數據類型是 T，其必須是與目標加速器相容的類型。雖然排名、 N（陣列是以靜態方式決定，而且是型別的一部分，但陣列的範圍是由運行時間決定，並使用類別 extent<N>表示。

數位可以有任意數目的維度，不過某些功能是針對 array 排名一、二和三的物件特製化。如果您省略維度自變數，預設值為1。

數位資料會在記憶體中連續配置。最小顯著維度中不同元素在記憶體中相鄰。

陣列會以邏輯方式視為實值型別，因為當陣列複製到另一個陣列時，就會執行深層複製。兩個陣列永遠不會指向相同的數據。

此 array<T,N> 類型用於數個案例：

作為可用於加速器計算的數據容器。
作為數據容器，用來保存主機 CPU 上的記憶體（可用來複製至其他陣列或從其他數位複製記憶體）。
做為預備物件，做為主機到裝置複本中快速媒介。

繼承階層架構

array

需求

標頭︰ amp.h

命名空間： 並行

~陣列

array終結物件。

~array() restrict(cpu);

accelerator_view

取得accelerator_view物件，表示配置數位的位置。此屬性只能在 CPU 上存取。

__declspec(property(get= get_accelerator_view)) Concurrency::accelerator_view accelerator_view;

陣列

初始化陣列類別的新實例。沒有的預設建構函式 array<T,N>。所有建構函式只會在CPU上執行。無法在 Direct3D 目標上執行它們。

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);

參數

_Associated_Av
指定數位慣用目標位置的accelerator_view。

_Av
指定陣列位置的 accelerator_view 物件。

_Cpu_access_type
CPU 上陣列所需的 access_type 。此參數的預設值 access_type_auto 是將CPU access_type 判斷保留給運行時間。您可以使用方法查詢get_cpu_access_type陣列的實際 CPUaccess_type。

_程度
陣列每個維度中的範圍。

_E0
本節範圍最重要的元件。

_E1
本節範圍中下一個最重要的元件。

_E2
本節範圍中最重要的元件。

_InputIterator
輸入迭代器的類型。

_Src
要複製的物件。

_Src_first
來源容器中的起始反覆運算器。

_Src_last
來源容器中的結束反覆運算器。

_其他
其他數據源。

_排
區段的排名。

value_type
複製之項目的數據類型。

associated_accelerator_view

取得呼叫暫存建構函式來具array現化物件時，做為參數傳遞的第二個accelerator_view物件。

__declspec(property(get= get_associated_accelerator_view)) Concurrency::accelerator_view associated_accelerator_view;

copy_to

複製的內容 array 複製到另一個 array。

void copy_to(
    array<value_type, _Rank>& _Dest) const ;

void copy_to(
    array_view<value_type, _Rank>& _Dest) const ;

參數

_Dest
要複製到其中的 array_view 物件。

cpu_access_type

取得這個陣列允許的CPU access_type。

__declspec(property(get= get_cpu_access_type)) access_type cpu_access_type;

資料

傳回之原始數據的 array指標。

value_type* data() restrict(amp, cpu);

const value_type* data() const restrict(amp, cpu);

傳回值

數位原始數據的指標。

extent

取得定義之圖形的範圍array物件。

__declspec(property(get= get_extent)) Concurrency::extent<_Rank> extent;

get_accelerator_view

會傳回accelerator_view 物件，代表配置物件的位置 array 。此屬性只能在 CPU 上存取。

Concurrency::accelerator_view get_accelerator_view() const;

傳回值

accelerator_view物件，表示配置物件的位置array。

get_associated_accelerator_view

取得呼叫暫存建構函式來具array現化物件時，做為參數傳遞的第二個accelerator_view物件。

Concurrency::accelerator_view get_associated_accelerator_view() const ;

傳回值

傳遞至暫存建構函式的第二個 accelerator_view物件。

get_cpu_access_type

傳回此陣列允許的CPU access_type。

access_type get_cpu_access_type() const restrict(cpu);

傳回值

get_extent

傳回的範圍物件array。

Concurrency::extent<_Rank> get_extent() const restrict(amp,cpu);

傳回值

extent的array物件。

`operator std::vector<value_type>`

使用 copy(*this, vector) 以隱含方式將陣列轉換成 std：：vector 物件。

operator std::vector<value_type>() const restrict(cpu);

參數

value_type
向量項目的數據類型。

傳回值

型 vector<T> 別的物件，其中包含數位中包含的數據複本。

operator()

傳回參數所指定的項目值。

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);

參數

_指數
專案的位置。

_I0
本節來源最重要的元件。

_I1
本節來源的下一到最重要元件。

_I2
本節來源最不重要的元件。

_I
專案的位置。

傳回值

參數所指定的專案值。

operator[]

傳回位於指定索引處的專案。

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);

參數

_指數
索引。

_I
索引。

傳回值

位於指定索引處的專案。

operator=

複製指定 array 之物件的內容。

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);

參數

_其他
要 array 從中複製的物件。

_Src
要 array 從中複製的物件。

傳回值

這個 array 對象的參考。

rank

儲存的 array排名。

static const int rank = _Rank;

reinterpret_as

透過一維array_view重新解譯數位，其中選擇性地可能有與來源陣列不同的實值類型。

語法

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);

參數

_Value_type2
傳回之數據的數據類型。

傳回值

以陣列為基礎的array_view或 const array_view 物件，元素類型會從 T 重新解譯為 ElementType，並將排名從 N 縮減為 1。

備註

有時候，檢視多維度陣列會很方便，就好像它是線性的一維陣列，可能具有與來源陣列不同的實值類型。您可以使用這個方法來達成此目的。注意使用不同實值類型重新解譯數位對像是可能不安全的作業。建議您謹慎使用這項功能。

下列程式碼提供一個範例。

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

傳回位於指定原點之 array 物件的子區段，並選擇性地傳回具有指定範圍的子區段。

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);

參數

_E0
本節範圍最重要的元件。

_E1
本節範圍中下一個最重要的元件。

_E2
本節範圍中最重要的元件。

_內線
指定區段範圍的範圍物件。原點為 0。

_Idx
指定原點位置的索引物件。子區段是範圍的其餘部分。

_I0
本節來源最重要的元件。

_I1
本節來源的下一到最重要元件。

_I2
本節來源最不重要的元件。

_排
區段的排名。

_Section_extent
指定區段範圍的範圍物件。

_Section_origin
指定原點位置的索引物件。

value_type
複製之項目的數據類型。

傳回值

傳回位於指定原點之 array 物件的子區段，並選擇性地傳回具有指定範圍的子區段。當只 index 指定物件時，子區段會包含相關聯方格中的所有專案，這些元素的索引大於物件中 index 專案的索引。

view_as

將這個陣列重新解譯為不同順位的array_view 。

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);

參數

_New_rank
傳遞為參數的物件 extent 排名。

_View_extent
用來建構新 array_view 物件的範圍。

value_type
原始 array 物件和傳 array_view 回之物件中的項目數據類型。

傳回值

所建構array_view 物件。

另請參閱

Concurrency 命名空間 (C++ AMP)

共用方式為