modèle de struct winrt ::com_array (C++/WinRT)

Représente un tableau de données conforme au style C où la mémoire tampon sous-jacente est allouée et libérée via l’allocateur de tâche COM, par conséquent le nom. Il est généralement utilisé pour représenter un tableau conforme au style C qui est alloué par un composant et libéré par un autre.

winrt ::com_array est utilisé pour passer des paramètres à et depuis des API Windows Runtime. Si vous créez des API, vous devrez probablement construire un winrt ::com_array pour retourner un tableau projeté à l’appelant ; soit comme valeur de retour, soit via un paramètre de sortie.

winrt ::com_array dérive de winrt ::array_view. Consultez la rubrique de modèle de struct winrt ::array_view, qui documente les membres et les opérateurs libres qui sont également disponibles pour winrt ::com_array. Toutefois, tenez compte de la différence entre la sémantique entre le type de base winrt ::array_view (qui est une vue non propriétaire, ou étendue, d’une série de valeurs contiguë) et winrt ::com_array (qui alloue et libère ses propres éléments).

Syntaxe

template <typename T>
struct com_array : winrt::array_view<T>

Paramètres de modèle

typename T Type des valeurs (éléments) que contient le com_array.

Exigences

Kit de développement logiciel (SDK) minimum pris en charge : SDK Windows version 10.0.17134.0 (Windows 10, version 1803)

Namespace : winrt

en-tête : %WindowsSdkDir%Include<WindowsTargetPlatformVersion>\cppwinrt\winrt\base.h (inclus par défaut)

Constructeurs

Fonctions membres

Opérateurs membres

Fonctions gratuites

constructeur com_array ::com_array

Initialise une nouvelle instance du struct com_array avec une copie des données d’entrée ou avec des valeurs par défaut de T si aucune donnée n’est fournie.

Syntaxe

Les constructeurs sont numérotés et décrits plus loin dans Remarques ci-dessous.

1.  com_array() noexcept;
2.  com_array(uint32_t const count);
3.  com_array(uint32_t const count, T const& value);
4.  template <typename InIt> com_array(InIt first, InIt last);
5.  com_array(std::vector<T> const& vectorValue);
6.  template <size_t N> com_array(std::array<T, N> const& arrayValue);
7.  template <uint32_t N> com_array(T const(&rawArrayValue)[N])
8.  com_array(std::initializer_list<T> initializerListValue);
9.  com_array(void* ptr, uint32_t const count, winrt::take_ownership_from_abi_t) noexcept;
10. com_array(com_array&& comArrayValue) noexcept;

Paramètres de modèle

typename InIt Itérateur d’entrée, qui fournit les données d’entrée.

size_t N uint32_t N Nombre de valeurs (éléments) dans les données d’entrée.

Paramètres

Valeur de std ::array qui initialise l’objet com_array.

comArrayValue un autre com_array qui initialise l’objet com_array. Une fois le constructeur retourné, comArrayValue sera vide.

count Nombre d’éléments de l’objet com_array.

first last paire d’itérateurs d’entrée. Les valeurs de la plage [premier, dernière) sont utilisées pour initialiser l’objet com_array.

initializerListValue Valeur de liste d’initialiseurs qui initialise l’objet com_array.

ptr Pointeur vers un bloc de valeurs N que vous avez allouées à l’aide de CoTaskMemAlloc. L’objet com_array prend possession de cette mémoire.

rawArrayValue tableau de style C qui initialise l’objet com_array.

value Valeur à donner à chaque élément de l’objet com_array.

vectorValue Valeur std ::vector qui initialise l’objet com_array.

Remarques

Les constructeurs sont numérotés dans syntaxe ci-dessus.

1. Constructeur par défaut

Construit une mémoire tampon vide.

2. Constructeur de capacité ; valeur par défaut

Crée une mémoire tampon de nombre d’éléments, qui sont toutes des copies d’une Tconstruite par défaut.

Ceci est similaire à (mais pas identique à) la création d’une mémoire tampon de nombre d’éléments, chacun étant un T construit par défaut.

auto players{ winrt::com_array<MediaPlayer>(50) };

Le constructeur par défaut de l’objet MediaPlayer crée une référence à un nouvel objet lecteur multimédia, et son constructeur de copie copie la référence. Par conséquent, la ligne de code ci-dessus crée un tableau de 50 références au même objet de lecteur multimédia. Il ne crée pas un tableau de 50 objets de lecteur multimédia différents.

3. Constructeur de capacité ; valeur explicite

Crée une mémoire tampon de nombre d’éléments, dont chacune est une copie de la valeur fournie.

winrt::com_array(2, 42) est interprétée comme une tentative d’utilisation du constructeur de plage (4). Mais il échoue parce que 2 et 42 ne sont pas itérateurs. Pour que cela soit interprété comme un constructeur de capacité avec une valeur de int32_t explicite, utilisez un entier explicitement non signé comme premier paramètre : com_array(2u, 42).

4. Constructeur de plage

Crée une mémoire tampon qui est une copie de la plage [premier, dernière).

Indiquez le type sous-jacent T explicitement, comme ceci.

auto a{ winrt::com_array<T>(source.begin(), source.end()) };

Pour déplacer la plage, au lieu de la copier, utilisez l’adaptateur d’itérateur std ::move_iterator.

auto a{ winrt::com_array<T>(std::move_iterator(source.begin()),
                            std::move_iterator(source.end())) };

5. Constructeur de vecteur

Crée une mémoire tampon qui est une copie du contenu de vectorValue.

6. Constructeur de tableau

Crée une mémoire tampon qui est une copie du contenu de arrayValue.

7. Constructeur de tableau de style C

Crée une mémoire tampon qui est une copie du contenu du tableau de style C rawArrayValue.

8. Constructeur initialiseur-list

Crée une mémoire tampon qui est une copie du contenu de la liste d’initialiseurs initializerListValue.

9. Constructeur ABI

Prend possession d’une mémoire tampon de longueur spécifiée.

Ce niveau le plus bas des constructeurs. Utilisez-le lorsque vous disposez d’un bloc de mémoire déjà alloué via CoTaskMemAlloc, et que vous souhaitez que le com_array assume sa responsabilité. Pour souligner les exigences particulières de ce constructeur, l’argument final doit être winrt ::take_ownership_from_abi.

10. Déplacer le constructeur

Déplace les ressources d’une autre com_array du même type, en laissant l’original vide.

Constructeurs 5, 6 et 7

Les copies sont extraites du contenu du conteneur fourni. Vous pouvez utiliser le constructeur de plage (4) avec le std ::move_iterator adaptateur d’itérateur pour déplacer le contenu dans le com_array au lieu de les copier.

com_array ::clear, fonction

Rend l’objet com_array vide.

Syntaxe

void clear() noexcept;

fonction detach_abi

Détache l’objet com_array de ses valeurs brutes, peut-être pour les renvoyer à un appelant. La com_array est effacée. Consultez également fonction winrt ::d etach_abi.

Syntaxe

auto detach_abi(winrt::com_array<T>& object) noexcept;
auto detach_abi(winrt::com_array<T>&& object) noexcept;

Paramètres

object objet com_array sur lequel opérer.

Valeur de retour

Tuple à deux éléments contenant un nombre d’éléments et la série contiguë de valeurs que le com_array s’étendait.

com_array ::operator= (opérateur d’affectation)

Affecte une valeur à l’objet com_array.

Syntaxe

com_array& operator=(winrt::com_array&& comArrayValue) noexcept;

Paramètres

comArrayValue valeur de com_array à affecter à l’objet com_array.

Valeur de retour

Référence à l’objet com_array.

fonction put_abi

Récupère l’adresse du com_array afin qu’elle puisse être définie sur une autre valeur. Consultez également fonction winrt ::p ut_abi.

Syntaxe

template<typename T> auto put_abi(winrt::com_array<T>& object) noexcept;

Paramètres

object objet com_array sur lequel opérer.

Valeur de retour

Adresse du com_array, prête à être définie sur une autre valeur.

swap, fonction

Échange le contenu des deux paramètres com_array.

Syntaxe

friend void swap(winrt::com_array& left, winrt::com_array& right) noexcept;

Paramètres

left right Valeur com_array dont le contenu doit s’échanger mutuellement avec ceux de l’autre paramètre.

Exemple

using namespace winrt;
...
    com_array<byte> left{ 1,2,3 };
    com_array<byte> right{ 4,5,6 };
    swap(left, right);

Voir aussi

• espace de noms winrt