array, classe
Représente un conteneur de données utilisé pour déplacer des données vers un accélérateur.
Syntaxe
template <typename value_type, int _Rank>
friend class array;
Paramètres
value_type
Type d’élément des données.
_Rang
Rang du tableau.
Membres
Constructeurs publics
| Nom | Description |
|---|---|
| constructeur de tableau | Initialise une nouvelle instance de la classe array. |
| ~array Destructor | Détruit l’objet array . |
Méthodes publiques
| Nom | Description |
|---|---|
| copy_to | Copie le contenu du tableau dans un autre tableau. |
| data | Retourne un pointeur vers les données brutes du tableau. |
| get_accelerator_view | Retourne l’objet accelerator_view qui représente l’emplacement où le tableau est alloué. Cette propriété est accessible uniquement sur le processeur. |
| get_associated_accelerator_view | Obtient le deuxième objet accelerator_view passé en tant que paramètre lorsqu’un constructeur intermédiaire est appelé pour instancier l’objet array . |
| get_cpu_access_type | Retourne la access_type du tableau. Cette méthode est accessible uniquement sur l’UC. |
| get_extent | Retourne l’objet d’extension du tableau. |
| reinterpret_as | Retourne un tableau unidimensionnel qui contient tous les éléments de l’objet array . |
| section | Retourne une sous-section de l’objet array qui se trouve à l’origine spécifiée et, éventuellement, qui a l’étendue spécifiée. |
| view_as | Retourne un objet array_view construit à partir de l’objet array . |
Opérateurs publics
| Nom | Description |
|---|---|
operator std::vector<value_type> |
Utilise copy(*this, vector) pour convertir implicitement le tableau en objet std ::vector . |
| operator() | Retourne la valeur de l’élément spécifiée par les paramètres. |
| operator[] | Retourne l’élément qui se trouve à l’index spécifié. |
| operator= | Copie le contenu de l’objet spécifié array dans celui-ci. |
Constantes publiques
| Nom | Description |
|---|---|
| constante de classement | Stocke le rang du tableau. |
Membres de données publics
| Nom | Description |
|---|---|
| accelerator_view | Obtient l’objet accelerator_view qui représente l’emplacement où le tableau est alloué. Cette propriété est accessible uniquement sur le processeur. |
| associated_accelerator_view | Obtient le deuxième objet accelerator_view passé en tant que paramètre lorsqu’un constructeur intermédiaire est appelé pour instancier l’objet array . |
| cpu_access_type | Obtient la access_type qui représente la façon dont l’UC peut accéder au stockage du tableau. |
| extent | Obtient l’étendue qui définit la forme du tableau. |
Notes
Le type array<T,N> représente un tableau ndimensionnel dense et régulier (non en jagged) situé dans un emplacement spécifique, tel qu’un accélérateur ou l’UC. Le type de données des éléments du tableau est T, qui doit être d’un type compatible avec l’accélérateur cible. Bien que le classement , N(du tableau est déterminé statiquement et fait partie du type, l’étendue du tableau est déterminée par le runtime et est exprimée à l’aide de la classe extent<N>.
Un tableau peut avoir n’importe quel nombre de dimensions, bien que certaines fonctionnalités soient spécialisées pour array les objets de rang 1, deux et trois. Si vous omettez l’argument de dimension, la valeur par défaut est 1.
Les données de tableau sont disposées contiguëment en mémoire. Les éléments qui diffèrent d’une dimension la moins significative sont adjacents à la mémoire.
Les tableaux sont logiquement considérés comme des types valeur, car lorsqu’un tableau est copié dans un autre tableau, une copie approfondie est effectuée. Deux tableaux ne pointent jamais vers les mêmes données.
Le array<T,N> type est utilisé dans plusieurs scénarios :
En tant que conteneur de données qui peut être utilisé dans les calculs sur un accélérateur.
En tant que conteneur de données pour contenir de la mémoire sur le processeur hôte (qui peut être utilisé pour copier vers et à partir d’autres tableaux).
En tant qu’objet intermédiaire pour agir en tant qu’intermédiaire rapide dans les copies d’hôte à appareil.
Hiérarchie d'héritage
array
Spécifications
En-tête : amp.h
Espace de noms : Concurrency
~Array
Détruit l’objet array .
~array() restrict(cpu);
accelerator_view
Obtient l’objet accelerator_view qui représente l’emplacement où le tableau est alloué. Cette propriété est accessible uniquement sur le processeur.
__declspec(property(get= get_accelerator_view)) Concurrency::accelerator_view accelerator_view;
tableau
Initialise une nouvelle instance de la classe de tableau. Il n’existe aucun constructeur par défaut pour array<T,N>. Tous les constructeurs sont exécutés sur le processeur uniquement. Ils ne peuvent pas être exécutés sur une cible 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);
Paramètres
_Associated_Av
Un accelerator_view qui spécifie l’emplacement cible préféré du tableau.
_Av
Objet accelerator_view qui spécifie l’emplacement du tableau.
_Cpu_access_type
La access_type souhaitée pour le tableau sur l’UC. Ce paramètre a une valeur par défaut pour access_type_auto laisser la détermination de l’UC access_type au runtime. L’UC access_type réelle du tableau peut être interrogée à l’aide de la get_cpu_access_type méthode.
_Mesure
Étendue dans chaque dimension du tableau.
_E0
Composant le plus important de l’étendue de cette section.
_E1
Composant suivant à la plus importante de l’étendue de cette section.
_E2
Composant le moins significatif de l’étendue de cette section.
_InputIterator
Type de l'itérateur d'entrée.
_Src
Objet à copier.
_Src_first
Itérateur de début dans le conteneur source.
_Src_last
Itérateur de fin dans le conteneur source.
_Autres
Autre source de données.
_Rang
Rang de la section.
value_type
Type de données des éléments copiés.
associated_accelerator_view
Obtient le deuxième objet accelerator_view passé en tant que paramètre lorsqu’un constructeur intermédiaire est appelé pour instancier l’objet array .
__declspec(property(get= get_associated_accelerator_view)) Concurrency::accelerator_view associated_accelerator_view;
copy_to
Copie le contenu de l’objet array vers un autre array.
void copy_to(
array<value_type, _Rank>& _Dest) const ;
void copy_to(
array_view<value_type, _Rank>& _Dest) const ;
Paramètres
_Dest
Objet array_view à copier.
cpu_access_type
Obtient le access_type processeur autorisé pour ce tableau.
__declspec(property(get= get_cpu_access_type)) access_type cpu_access_type;
data
Retourne un pointeur vers les données brutes du array.
value_type* data() restrict(amp, cpu);
const value_type* data() const restrict(amp, cpu);
Valeur de retour
Pointeur vers les données brutes du tableau.
extent
Obtient l’objet d’extension qui définit la forme du array.
__declspec(property(get= get_extent)) Concurrency::extent<_Rank> extent;
get_accelerator_view
Retourne l’objet accelerator_view qui représente l’emplacement où l’objet array est alloué. Cette propriété est accessible uniquement sur le processeur.
Concurrency::accelerator_view get_accelerator_view() const;
Valeur de retour
Objet accelerator_view qui représente l’emplacement où l’objet array est alloué.
get_associated_accelerator_view
Obtient le deuxième objet accelerator_view passé en tant que paramètre lorsqu’un constructeur intermédiaire est appelé pour instancier l’objet array .
Concurrency::accelerator_view get_associated_accelerator_view() const ;
Valeur de retour
Deuxième objet accelerator_view passé au constructeur intermédiaire.
get_cpu_access_type
Retourne la access_type processeur autorisée pour ce tableau.
access_type get_cpu_access_type() const restrict(cpu);
Valeur de retour
get_extent
Renvoie l’objet d’étendue du array.
Concurrency::extent<_Rank> get_extent() const restrict(amp,cpu);
Valeur de retour
Objet extent de l'objet array.
operator std::vector<value_type>
Utilise copy(*this, vector) pour convertir implicitement le tableau en objet std ::vector.
operator std::vector<value_type>() const restrict(cpu);
Paramètres
value_type
Type de données des éléments du vecteur.
Valeur de retour
Objet de type vector<T> qui contient une copie des données contenues dans le tableau.
operator()
Retourne la valeur de l’élément spécifiée par les paramètres.
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);
Paramètres
_Index
Emplacement de l’élément.
_I0
Composant le plus significatif de l’origine de cette section.
_I1
Composant suivant à la plus importante de l’origine de cette section.
_I2
Composant le moins significatif de l’origine de cette section.
_I
Emplacement de l’élément.
Valeur de retour
Valeur de l’élément spécifiée par les paramètres.
operator[]
Retourne l’élément qui se trouve à l’index spécifié.
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);
Paramètres
_Index
Index.
_I
Index.
Valeur de retour
Élément qui se trouve à l’index spécifié.
opérateur =
Copie le contenu de l’objet spécifié 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);
Paramètres
_Autres
Objet array à copier.
_Src
Objet array à copier.
Valeur de retour
Référence à cet array objet.
rank
Stocke le rang du array.
static const int rank = _Rank;
reinterpret_as
Réinterprète le tableau par le biais d’un array_view unidimensionnel, qui peut éventuellement avoir un type de valeur différent du tableau source.
Syntaxe
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);
Paramètres
_Value_type2
Type de données des données retournées.
Valeur de retour
Objet array_view ou const array_view basé sur le tableau, avec le type d’élément réinterprété de T à ElementType et le rang réduit de N à 1.
Notes
Parfois, il est pratique d’afficher un tableau multidimensionnel comme s’il s’agit d’un tableau linéaire unidimensionnel, éventuellement avec un type de valeur différent du tableau source. Vous pouvez utiliser cette méthode pour y parvenir. Attention à réinterpréter un objet tableau à l’aide d’un type valeur différent est une opération potentiellement dangereuse. Nous vous recommandons d’utiliser attentivement cette fonctionnalité.
Le code suivant montre un exemple.
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
Retourne une sous-section de l’objet array qui se trouve à l’origine spécifiée et, éventuellement, qui a l’étendue spécifiée.
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);
Paramètres
_E0
Composant le plus important de l’étendue de cette section.
_E1
Composant suivant à la plus importante de l’étendue de cette section.
_E2
Composant le moins significatif de l’étendue de cette section.
_Poste
Objet d’extension qui spécifie l’étendue de la section. L’origine est 0.
_Idx
Objet d’index qui spécifie l’emplacement de l’origine. La sous-section correspond au reste de l’étendue.
_I0
Composant le plus significatif de l’origine de cette section.
_I1
Composant suivant à la plus importante de l’origine de cette section.
_I2
Composant le moins significatif de l’origine de cette section.
_Rang
Rang de la section.
_Section_extent
Objet d’extension qui spécifie l’étendue de la section.
_Section_origin
Objet d’index qui spécifie l’emplacement de l’origine.
value_type
Type de données des éléments copiés.
Valeur de retour
Retourne une sous-section de l’objet array qui se trouve à l’origine spécifiée et, éventuellement, qui a l’étendue spécifiée. Lorsque seul l’objet index est spécifié, la sous-section contient tous les éléments de la grille associée qui ont des index supérieurs aux index des éléments de l’objet index .
view_as
Réinterpret ce tableau en tant que array_view d’un rang différent.
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);
Paramètres
_New_rank
Rang de l’objet extent passé en tant que paramètre.
_View_extent
Étendue utilisée pour construire le nouvel objet array_view .
value_type
Type de données des éléments dans l’objet d’origine array et l’objet retourné array_view .
Valeur de retour
Objet array_view construit.
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour