array Classe

Representa um contêiner de dados usado para mover dados para um acelerador.

Sintaxe

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

Parâmetros

value_type
O tipo de elemento dos dados.

_Rank
A classificação da matriz.

Membros

Construtores Públicos

Nome	Descrição
array Construtor	Inicializa uma nova instância da classe `array`.
~array Destruidor	Destrói o `array` objeto.

Métodos Públicos

Nome	Descrição
copy_to	Copia o conteúdo da matriz para outra matriz.
Dados	Retorna um ponteiro para os dados brutos da matriz.
get_accelerator_view	Retorna o objeto accelerator_view que representa o local onde a matriz está alocada. Esta propriedade pode ser acessada somente na CPU.
get_associated_accelerator_view	Obtém o segundo objeto accelerator_view que é passado como um parâmetro quando um construtor de preparo é chamado para instanciar o `array` objeto.
get_cpu_access_type	Retorna o access_type da matriz. Este método pode ser acessado somente na CPU.
get_extent	Retorna o objeto extent da matriz.
reinterpret_as	Retorna uma matriz unidimensional que contém todos os elementos no `array` objeto.
secção	Retorna uma subseção do `array` objeto que está na origem especificada e, opcionalmente, que tem a extensão especificada.
view_as	Retorna um objeto array_view que é construído a partir do `array` objeto.

Operadores Públicos

Nome	Descrição
`operator std::vector<value_type>`	Usa `copy(*this, vector)` para converter implicitamente a matriz em um objeto std::vetor .
operador(es)	Retorna o valor do elemento especificado pelos parâmetros.
operador[]	Retorna o elemento que está no índice especificado.
operador=	Copia o conteúdo do objeto especificado `array` para este.

Constantes Públicas

Nome	Descrição
rank Constante	Armazena a classificação da matriz.

Membros de Dados Públicos

Nome	Descrição
accelerator_view	Obtém o objeto accelerator_view que representa o local onde a matriz está alocada. Esta propriedade pode ser acessada somente na CPU.
associated_accelerator_view	Obtém o segundo objeto accelerator_view que é passado como um parâmetro quando um construtor de preparo é chamado para instanciar o `array` objeto.
cpu_access_type	Obtém o access_type que representa como a CPU pode acessar o armazenamento da matriz.
Extensão	Obtém a extensão que define a forma da matriz.

Observações

O tipo array<T,N> representa uma matriz N-dimensional densa e regular (não irregular) que está localizada em um local específico, como um acelerador ou a CPU. O tipo de dados dos elementos na matriz é T, que deve ser de um tipo compatível com o acelerador de destino. Embora a classificação, N, (da matriz seja determinada estaticamente e faça parte do tipo, a extensão da matriz é determinada pelo tempo de execução e é expressa usando a classe extent<N>.

Uma matriz pode ter qualquer número de dimensões, embora algumas funcionalidades sejam especializadas para array objetos com classificação um, dois e três. Se você omitir o argumento de dimensão, o padrão será 1.

Os dados da matriz são dispostos de forma contígua na memória. Elementos que diferem por um na dimensão menos significativa são adjacentes na memória.

As matrizes são logicamente consideradas como tipos de valor, porque quando uma matriz é copiada para outra matriz, uma cópia profunda é executada. Duas matrizes nunca apontam para os mesmos dados.

O array<T,N> tipo é usado em vários cenários:

Como um contêiner de dados que pode ser usado em cálculos em um acelerador.
Como um contêiner de dados para armazenar memória na CPU do host (que pode ser usada para copiar de e para outras matrizes).
Como um objeto de preparo para atuar como um intermediário rápido em cópias de host para dispositivo.

Hierarquia de herança

array

Requerimentos

Cabeçalho: amp.h

Namespace: simultaneidade

~matriz

Destrói o array objeto.

~array() restrict(cpu);

accelerator_view

Obtém o objeto accelerator_view que representa o local onde a matriz está alocada. Esta propriedade pode ser acessada somente na CPU.

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

matriz

Inicializa uma nova instância da classe de matriz. Não há nenhum construtor padrão para array<T,N>. Todos os construtores são executados apenas na CPU. Eles não podem ser executados em um destino 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);

Parâmetros

_Associated_Av
Um accelerator_view que especifica o local de destino preferencial da matriz.

_Av
Um objeto accelerator_view que especifica o local da matriz.

_Cpu_access_type
O access_type desejado para o array na CPU. Este parâmetro tem um valor padrão de deixar a determinação da CPU access_type para o tempo de access_type_auto execução. A CPU access_type real para a matriz pode ser consultada usando o get_cpu_access_type método.

_Extent
A extensão em cada dimensão da matriz.

_E0
O componente mais significativo da extensão desta seção.

_E1
O componente mais significativo da extensão desta seção.

_E2
A componente menos significativa da extensão desta secção.

_InputIterator
O tipo do iterador de entrada.

_Src
Para se opor à cópia.

_Src_first
Um iterador inicial no contêiner de origem.

_Src_last
Um iterador final no contêiner de origem.

_Other
Outra fonte de dados.

_Rank
A classificação da secção.

value_type
O tipo de dados dos elementos que são copiados.

associated_accelerator_view

Obtém o segundo objeto accelerator_view que é passado como um parâmetro quando um construtor de preparo é chamado para instanciar o array objeto.

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

copy_to

Copia array o conteúdo do para outro array.

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

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

Parâmetros

_Dest
O array_view objeto para o qual copiar.

cpu_access_type

Obtém o access_type de CPU permitido para essa matriz.

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

dados

Retorna um ponteiro para os dados brutos do array.

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

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

Valor de retorno

Um ponteiro para os dados brutos da matriz.

extensão

Obtém o objeto de extensão que define a forma do arrayarquivo .

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

get_accelerator_view

Retorna o objeto accelerator_view que representa o local onde o array objeto está alocado. Esta propriedade pode ser acessada somente na CPU.

Concurrency::accelerator_view get_accelerator_view() const;

Valor de retorno

O accelerator_view objeto que representa o local onde o array objeto está alocado.

get_associated_accelerator_view

Obtém o segundo objeto accelerator_view que é passado como um parâmetro quando um construtor de preparo é chamado para instanciar o array objeto.

Concurrency::accelerator_view get_associated_accelerator_view() const ;

Valor de retorno

O segundo objeto accelerator_view passou para o construtor de preparo.

get_cpu_access_type

Retorna a access_type da CPU permitida para essa matriz.

access_type get_cpu_access_type() const restrict(cpu);

Valor de retorno

get_extent

Devolve o objeto extent do arrayficheiro .

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

Valor de retorno

O extent objeto do array.

`operator std::vector<value_type>`

Usa copy(*this, vector) para converter implicitamente a matriz em um objeto std::vetor.

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

Parâmetros

value_type
O tipo de dados dos elementos do vetor.

Valor de retorno

Um objeto do tipo vector<T> que contém uma cópia dos dados contidos na matriz.

operador()

Retorna o valor do elemento especificado pelos parâmetros.

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

Parâmetros

_Index
A localização do elemento.

_I0
O componente mais significativo da origem desta seção.

_I1
O componente mais significativo da origem desta seção.

_I2
A componente menos significativa da origem desta secção.

_Eu
A localização do elemento.

Valor de retorno

O valor do elemento especificado pelos parâmetros.

operador[]

Retorna o elemento que está no índice especificado.

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

Parâmetros

_Index
O índice.

_Eu
O índice.

Valor de retorno

O elemento que está no índice especificado.

operador=

Copia o conteúdo do objeto especificado 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);

Parâmetros

_Other
O array objeto do qual copiar.

_Src
O array objeto do qual copiar.

Valor de retorno

Uma referência a isso array objeto.

classificar

Armazena a classificação do array.

static const int rank = _Rank;

reinterpret_as

Reinterpreta a matriz por meio de uma array_view unidimensional, que opcionalmente pode ter um tipo de valor diferente da matriz de origem.

Sintaxe

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

Parâmetros

_Value_type2
O tipo de dados dos dados retornados.

Valor de retorno

Um array_view ou const array_view objeto baseado na matriz, com o tipo de elemento reinterpretado de T para ElementType e a classificação reduzida de N para 1.

Observações

Às vezes, é conveniente visualizar uma matriz multidimensional como se fosse uma matriz linear unidimensional, possivelmente com um tipo de valor diferente da matriz de origem. Você pode usar esse método para conseguir isso. Atenção Reinterpretar um objeto de matriz usando um tipo de valor diferente é uma operação potencialmente insegura. Recomendamos que utilize esta funcionalidade cuidadosamente.

O código a seguir fornece um exemplo.

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

seção

Retorna uma subseção do array objeto que está na origem especificada e, opcionalmente, que tem a extensão especificada.

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

Parâmetros

_E0
O componente mais significativo da extensão desta seção.

_E1
O componente mais significativo da extensão desta seção.

_E2
A componente menos significativa da extensão desta secção.

_Ext
O objeto extent que especifica a extensão da seção. A origem é 0.

_Idx
O objeto de índice que especifica o local da origem. A subsecção é o resto da extensão.

_I0
O componente mais significativo da origem desta seção.

_I1
O componente mais significativo da origem desta seção.

_I2
A componente menos significativa da origem desta secção.

_Rank
A classificação da secção.

_Section_extent
O objeto extent que especifica a extensão da seção.

_Section_origin
O objeto de índice que especifica o local da origem.

value_type
O tipo de dados dos elementos que são copiados.

Valor de retorno

Retorna uma subseção do array objeto que está na origem especificada e, opcionalmente, que tem a extensão especificada. Quando apenas o index objeto é especificado, a subseção contém todos os elementos na grade associada que têm índices maiores do que os índices dos elementos no index objeto.

view_as

Reinterpreta essa matriz como uma array_view de uma classificação diferente.

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

Parâmetros

_New_rank
A classificação do extent objeto passado como um parâmetro.

_View_extent
A extensão que é usada para construir o novo objeto array_view .

value_type
O tipo de dados dos elementos no objeto original array e no objeto retornado array_view .

Valor de retorno

O array_view objeto que é construído.

Ver também

Namespace de simultaneidade (C++ AMP)

Comentários

Esta página foi útil?

Last updated on 2025-11-07

Partilhar via

array Classe

Sintaxe

Parâmetros

Membros

Construtores Públicos

Métodos Públicos

Operadores Públicos

Constantes Públicas

Membros de Dados Públicos

Observações

Hierarquia de herança

Requerimentos

~matriz

accelerator_view

matriz

Parâmetros

associated_accelerator_view

copy_to

Parâmetros

cpu_access_type

dados

Valor de retorno

extensão

get_accelerator_view

Valor de retorno

get_associated_accelerator_view

Valor de retorno

get_cpu_access_type

Valor de retorno

get_extent

Valor de retorno

operator std::vector<value_type>

Parâmetros

Valor de retorno

operador()

Parâmetros

Valor de retorno

operador[]

Parâmetros

Valor de retorno

operador=

Parâmetros

Valor de retorno

classificar

reinterpret_as

Sintaxe

Parâmetros

Valor de retorno

Observações

seção

Parâmetros

Valor de retorno

view_as

Parâmetros

Valor de retorno

Ver também

Comentários

Recursos adicionais

`operator std::vector<value_type>`