分享方式：

array_view 類別

  • 文章

代表另一個容器中所保存數據的 N 維檢視。

語法

template <
    typename value_type,
    int _Rank = 1
>
class array_view : public _Array_view_base<_Rank, sizeof(value_type)/sizeof(int)>;

template <
    typename value_type,
    int _Rank
>
class array_view<const value_type, _Rank> : public _Array_view_base<_Rank, sizeof(value_type)/sizeof(int)>;

參數

value_type
對象中 array_view 項目的數據型別。

_排
物件的排名 array_view 。

成員

公用建構函式

名稱 描述
array_view建構函式 初始化 array_view 類別的新執行個體。 沒有的預設建構函式 array<T,N>。 所有建構函式都僅限於在CPU上執行，而且無法在 Direct3D 目標上執行。
~array_view解構函式 array_view終結物件。

公用方法

名稱 描述
copy_to 呼叫 copy(*this, dest)，將物件的內容array_view複製到指定的目的地。
data 傳回 之原始數據的 array_view指標。
discard_data 捨棄此檢視基礎的目前數據。
get_extent 傳回array_view物件的範圍物件。
get_ref 傳回索引項目的參考。
get_source_accelerator_view 傳回 數據源所在的accelerator_viewarray_view。
刷新 通知 array_view 物件，其系結記憶體已在 介面外部 array_view 修改。 對此方法的呼叫會呈現所有快取資訊過時。
reinterpret_as 傳回一維陣列，其中包含物件中的所有 array_view 專案。
section 傳回位於指定原點之 物件的子區段，並選擇性地傳回具有指定範圍的 子區 array_view 段。
synchronize 將對 array_view 物件所做的任何修改同步處理回其源數據。
synchronize_async 以異步方式將對 array_view 物件所做的任何修改同步處理回其源數據。
synchronize_to 將對 array_view 物件所做的任何修改同步處理至指定的 accelerator_view。
synchronize_to_async 以異步方式將對 array_view 物件所做的任何修改同步處理至指定的 accelerator_view。
view_as array_view使用這個array_view物件的數據產生不同排名的物件。

公用運算子

名稱 描述
operator（） 傳回參數或參數所指定的專案值。
operator[] 傳回參數所指定的專案。
operator= 將指定 array_view 之物件的內容複製到這個物件中。

公用常數

名稱 描述
rank 常數 儲存物件的排名 array_view 。

資料成員

名稱 描述
extent 取得定義 extent 物件形狀的 array_view 物件。
source_accelerator_view 取得資料來源所在的accelerator_view array_view
value_type 和係結陣列的 array_view 實值型別。

備註

類別array_view代表包含在數位對象或物件子區段中的數據檢視array。

您可以存取 array_view 原始資料所在的物件（本機）或位於不同的加速器或一致性定義域（遠端）。 當您從遠端存取物件時，會視需要複製和快取檢視。 除了自動快取的效果之外， array_view 物件具有與 array 對象類似的效能配置檔。 當您透過檢視存取資料時，效能會降低。

有三種遠端使用案例：

  • 系統記憶體指標的檢視會透過 對加速器的parallel_for_each 呼叫，並在加速器上存取。

  • 位於加速器上的數位檢視會透過呼叫另一 parallel_for_each 個加速器並在那裡存取。

  • 在CPU上存取位於加速器上的數位檢視。

在上述任一案例中，參考的檢視會由運行時間複製到遠端位置，如果呼叫 物件修改 array_view ，則會複製到本機位置。 運行時間可能會優化複製變更的程式、只複製已變更的專案，或可能也會複製未變更的部分。 array_view不保證一個數據源上的重迭對象在遠端位置維持引用完整性。

您必須同步處理相同資料來源的任何多線程存取。

執行時間會針對 物件中的數據 array_view 快取做出下列保證：

  • 所有同步處理良好的物件存取 array ，以及 array_view 程式順序中對象的物件都遵守序列發生前的關聯性。

  • 單一array物件上相同快捷鍵上重迭array_view物件的所有同步存取都會透過 array 對象進行別名處理。 它們會引發完全遵循程序順序的前置關聯性。 沒有快取。 array_view如果物件在不同的加速器上執行，則存取順序為未定義，並建立競爭條件。

當您在系統記憶體中使用指標建立array_view物件時，您只能透過array_view指標變更檢視array_view物件。 或者，如果基礎原生記憶體直接變更，而不是透過 array_view 物件呼叫附加至系統指標的其中array_view一個物件，則您必須refresh()呼叫 。

任一動作會通知 array_view 對象基礎原生記憶體已變更，且位於加速器上的任何復本都已過期。 如果您遵循這些指導方針，指標型檢視會與提供給數據平行數位列數位列檢視的檢視相同。

繼承階層架構

_Array_view_shape

_Array_view_base

array_view

需求

標頭︰ amp.h

命名空間： 並行

~array_view

array_view終結物件。

~array_view()restrict(amp,cpu);

array_view

初始化 array_view 類別的新執行個體。

array_view(
    array<value_type, _Rank>& _Src)restrict(amp,cpu);

array_view(
    const array_view& _Other)restrict(amp,cpu);

explicit array_view(
    const Concurrency::extent<_Rank>& _Extent) restrict(cpu);

template <
    typename _Container
>
array_view(
    const Concurrency::extent<_Rank>& _Extent,
    _Container& _Src) restrict(cpu);

array_view(
    const Concurrency::extent<_Rank>& _Extent,
    value_type* _Src)restrict(amp,cpu);

explicit array_view(
    int _E0) restrict(cpu);

template <
    typename _Container
>
explicit array_view(
    _Container& _Src,
    typename std::enable_if<details::_Is_container<_Container>::type::value, void **>::type = 0) restrict(cpu);

template <
    typename _Container
>
explicit array_view(
    int _E0,
    _Container& _Src) restrict(cpu);

explicit array_view(
    int _E0,
    int _E1) __CPU_ONLY;

template <
    typename _Container
>
explicit array_view(
    int _E0,
    int _E1,
    _Container& _Src) restrict(cpu);

explicit array_view(
    int _E0,
    int _E1,
    int _E2) __CPU_ONLY;

template <
    typename _Container
>
explicit array_view(
    int _E0,
    int _E1,
    int _E2,
    _Container& _Src);

explicit array_view(
    int _E0,
    _In_ value_type* _Src)restrict(amp,cpu);

template <
    typename _Arr_type,
    int _Size
>
explicit array_view(
    _In_ _Arr_type (& _Src) [_Size]) restrict(amp,cpu);

explicit array_view(
    int _E0,
    int _E1,
    _In_ value_type* _Src)restrict(amp,cpu);

explicit array_view(
    int _E0,
    int _E1,
    int _E2,
    _In_ value_type* _Src)restrict(amp,cpu);

array_view(
    const array<value_type, _Rank>& _Src)restrict(amp,cpu);

array_view(
    const array_view<value_type, _Rank>& _Src)restrict(amp,cpu);

array_view(
    const array_view<const value_type, _Rank>& _Src)restrict(amp,cpu);

template <
    typename _Container
>
array_view(
    const Concurrency::extent<_Rank>& _Extent,
    const _Container& _Src) restrict(cpu);

template <
    typename _Container
>
explicit array_view(
    const _Container& _Src,
    typename std::enable_if<details::_Is_container<_Container>::type::value, void **>::type = 0) restrict(cpu);

array_view(
    const Concurrency::extent<_Rank>& _Extent,
    const value_type* _Src)restrict(amp,cpu);

template <
    typename _Arr_type,
    int _Size
>
explicit array_view(
    const _In_ _Arr_type (& _Src) [_Size]) restrict(amp,cpu);

template <
    typename _Container
>
array_view(
    int _E0,
    const _Container& _Src);

template <
    typename _Container
>
array_view(
    int _E0,
    int _E1,
    const _Container& _Src);

template <
    typename _Container
>
array_view(
    int _E0,
    int _E1,
    int _E2,
    const _Container& _Src);

array_view(
    int _E0,
    const value_type* _Src)restrict(amp,cpu);

array_view(
    int _E0,
    int _E1,
    const value_type* _Src) restrict(amp,cpu);

array_view(
    int _E0,
    int _E1,
    int _E2,
    const value_type* _Src) restrict(amp,cpu);

參數

_Arr_type
提供數據的來源 C 樣式陣列元素類型。

_容器
範本自變數，必須指定支持 data() 和 size() 成員的線性容器。

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

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

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

_程度
這個 array_view的每個維度中的範圍。

_其他
型 array_view<T,N> 別的物件，要從中初始化新的 array_view。

_大小
提供數據的 C 樣式陣列大小。

_Src
將複製到新陣列之源數據的指標。

copy_to

藉由呼叫 copy(*this, dest)，將 對象的內容array_view複製到指定的目的地物件。

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

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

參數

_Dest
要複製到的物件。

資料

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

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

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

傳回值

之原始數據的 array_view指標。

discard_data

捨棄此檢視基礎的目前數據。 這是運行時間的優化提示，用來避免將檢視的目前內容複製到存取的目標 accelerator_view ，如果不需要現有內容，則建議使用它。 在 restrict（amp） 內容中使用此方法時，這個方法為 no-op

void discard_data() const restrict(cpu);

extent

取得定義 extent 物件形狀的 array_view 物件。

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

get_extent

傳 回 物件的範圍 物件 array_view 。

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

傳回值

物件的 extent 物件array_view

get_ref

取得_Index所編製索引之項目的參考。 不同於存取 CPU 上array_view的其他索引運算符，此方法不會隱含地將此array_view的內容同步處理至 CPU。 存取遠端位置上的array_view或執行涉及此array_view使用者的複製作業后，必須負責在呼叫此方法之前明確同步處理array_view到 CPU。 無法這樣做會導致未定義的行為。

value_type& get_ref(
    const index<_Rank>& _Index) const restrict(amp, cpu);

參數

_指數
索引。

傳回值

_Index所編製索引之項目的參考

get_source_accelerator_view

傳回array_view數據源所在的accelerator_view。 如果array_view沒有數據源，此 API 會擲回runtime_exception

accelerator_view get_source_accelerator_view() const;

傳回值

operator()

傳回參數或參數所指定的專案值。

value_type& operator() (
    const index<_Rank>& _Index) const restrict(amp,cpu);

typename details::_Projection_result_type<value_type,_Rank>::_Result_type operator() (
    int _I) const restrict(amp,cpu);

value_type& operator() (
    int _I0,
    int _I1) const restrict(amp,cpu);

value_type& operator() (
    int _I0,
    int _I1,
    int _I2) const 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[]

傳回參數所指定的專案。

typename details::_Projection_result_type<value_type,_Rank>::_Const_result_type operator[] (
    int _I) const restrict(amp,cpu);

value_type& operator[] (
    const index<_Rank>& _Index) const restrict(amp,cpu);

參數

_指數
索引。

_I
索引。

傳回值

索引處的專案值，或 array_view 投影在最重要的維度上。

operator=

將指定 array_view 物件的內容複製到這個物件。

array_view& operator= (
    const array_view& _Other) restrict(amp,cpu);

array_view& operator= (
    const array_view<value_type, _Rank>& _Other) restrict(amp,cpu);

參數

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

傳回值

這個 array_view 對象的參考。

rank

儲存物件的排名 array_view 。

static const int rank = _Rank;

重新整理

通知 array_view 物件，其系結記憶體已在 介面外部 array_view 修改。 對此方法的呼叫會呈現所有快取資訊過時。

void refresh() const restrict(cpu);

reinterpret_as

透過一維array_view重新解譯array_view，因為選項的實值類型可能不同於來源array_view。

語法

template <
    typename _Value_type2
>
array_view< _Value_type2, _Rank> reinterpret_as() const restrict(amp,cpu);

template <
    typename _Value_type2
>
array_view<const _Value_type2, _Rank> reinterpret_as() const restrict(amp,cpu);

參數

_Value_type2
新 array_view 物件的數據類型。

傳回值

以array_view這個 array_view為基礎的物件或 const array_view 物件，專案類型從 轉換成 T _Value_type2，且排名從 N 減少為 1。

備註

有時候，將多維度陣列檢視為線性、一維陣列，其可能具有與來源陣列不同的實值類型是很方便的。 您可以使用此方法在 上 array_view 達成此目的。

警告 使用不同實值型別重新解譯array_view對像是可能不安全的作業。 這項功能應該小心使用。

以下是範例：

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_view 段。

array_view section(
    const Concurrency::index<_Rank>& _Section_origin,
    const Concurrency::extent<_Rank>& _Section_extent) const restrict(amp,cpu);

array_view section(
    const Concurrency::index<_Rank>& _Idx) const restrict(amp,cpu);

array_view section(
    const Concurrency::extent<_Rank>& _Ext) const restrict(amp,cpu);

array_view section(
    int _I0,
    int _E0) const restrict(amp,cpu);

array_view section(
    int _I0,
    int _I1,
    int _E0,
    int _E1) const restrict(amp,cpu);

array_view 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
指定原點位置的索引物件。

傳回值

位於指定原點之 物件的子區段，以及具有指定範圍之選擇性的 子區 array_view 段。 當只 index 指定 物件時，子區段會包含關聯範圍中的所有專案，這些元素的索引大於物件中 index 專案的索引。

source_accelerator_view

取得與這個array_view相關聯的來源accelerator_view。

__declspec(property(get= get_source_accelerator_view)) accelerator_view source_accelerator_view;

synchronize

將對 array_view 物件所做的任何修改同步處理回其源數據。

void synchronize(access_type _Access_type = access_type_read) const restrict(cpu);

void synchronize() const restrict(cpu);

參數

_Access_type
目標accelerator_view上的預期access_type。 此參數預設值為 access_type_read。

synchronize_async

以異步方式將對 array_view 物件所做的任何修改同步處理回其源數據。

concurrency::completion_future synchronize_async(access_type _Access_type = access_type_read) const restrict(cpu);

concurrency::completion_future synchronize_async() const restrict(cpu);

參數

_Access_type
目標accelerator_view上的預期access_type。 此參數預設值為 access_type_read。

傳回值

要等候作業完成的未來。

synchronize_to

將對此array_view所做的任何修改同步處理至指定的accelerator_view。

void synchronize_to(
    const accelerator_view& _Accl_view,
    access_type _Access_type = access_type_read) const restrict(cpu);

void synchronize_to(
    const accelerator_view& _Accl_view) const restrict(cpu);

參數

_Accl_view
要同步的目標accelerator_view。

_Access_type
目標accelerator_view上所需的access_type。 此參數的預設值為 access_type_read。

synchronize_to_async

以異步方式將對此array_view所做的任何修改同步處理至指定的accelerator_view。

concurrency::completion_future synchronize_to_async(
    const accelerator_view& _Accl_view,
    access_type _Access_type = access_type_read) const restrict(cpu);

concurrency::completion_future synchronize_to_async(
    const accelerator_view& _Accl_view) const restrict(cpu);

參數

_Accl_view
要同步的目標accelerator_view。

_Access_type
目標accelerator_view上所需的access_type。 此參數的預設值為 access_type_read。

傳回值

要等候作業完成的未來。

value_type

array_view和系結陣列的實值型別。

typedef typenamevalue_type value_type;

view_as

將此值 array_view 重新解譯為 array_view 不同等級的 。

template <
    int _New_rank
>
array_view<value_type,_New_rank> view_as(
    const Concurrency::extent<_New_rank>& _View_extent) const 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
新 array_view 物件的排名。

_View_extent
重新調整 extent。

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

傳回值

建 array_view 構的物件。

另請參閱

Concurrency 命名空間 (C++ AMP)