`<cliext/adapter>` (STL/CLR)

Article
07/05/2024

L’en-tête <cliext/adapter> STL/CLR spécifie deux modèles de classe (collection_adapter et range_adapter) et le modèle de make_collectionfonction .

Syntaxe

#include <cliext/adapter>

Spécifications

Header :<cliext/adapter>

Espace de noms : cliext

Déclarations

Classe	Description
`collection_adapter`	Encapsule la collection BCL (Base Class Library) en tant que plage.
`range_adapter`	Encapsule la plage en tant que collection BCL.

Fonction	Description
`make_collection`	Crée un adaptateur de plage à l’aide d’une paire d’itérateurs.

Membres

`collection_adapter`

Encapsule une collection .NET à utiliser comme conteneur STL/CLR. A collection_adapter est une classe de modèle qui décrit un objet conteneur STL/CLR simple. Il encapsule une interface BCL (Base Class Library) et retourne une paire itérateur que vous utilisez pour manipuler la séquence contrôlée.

Syntaxe

template<typename Coll>
    ref class collection_adapter;

template<>
    ref class collection_adapter<
        System::Collections::ICollection>;
template<>
    ref class collection_adapter<
        System::Collections::IEnumerable>;
template<>
    ref class collection_adapter<
        System::Collections::IList>;
template<>
    ref class collection_adapter<
        System::Collections::IDictionary>;
template<typename Value>
    ref class collection_adapter<
        System::Collections::Generic::ICollection<Value>>;
template<typename Value>
    ref class collection_adapter<
        System::Collections::Generic::IEnumerable<Value>>;
template<typename Value>
    ref class collection_adapter<
        System::Collections::Generic::IList<Value>>;
template<typename Key,
    typename Value>
    ref class collection_adapter<
        System::Collections::Generic::IDictionary<Key, Value>>;

Paramètres

Coll
Type de la collection encapsulée.

Spécialisations

de la charge de travail	Description
`IEnumerable`	Séquences via des éléments.
`ICollection`	Conserve un groupe d’éléments.
`IList`	Conserve un groupe ordonné d’éléments.
`IDictionary`	Conservez un ensemble de paires {key, value}.
`IEnumerable<Value>`	Séquences par le biais d’éléments typés.
`ICollection<Value>`	Gère un groupe d’éléments typés.
`IList<Value>`	Gère un groupe ordonné d’éléments typés.
`IDictionary<Value>`	Gère un ensemble de paires {key, value} typées.

Membres

Définition de types	Description
`collection_adapter::difference_type`	Type d'une distance signée entre deux éléments.
`collection_adapter::iterator`	Type d'un itérateur pour la séquence contrôlée.
`collection_adapter::key_type`	Type d’une clé de dictionnaire.
`collection_adapter::mapped_type`	Type d’une valeur de dictionnaire.
`collection_adapter::reference`	Type d'une référence à un élément.
`collection_adapter::size_type`	Type d'une distance signée entre deux éléments.
`collection_adapter::value_type`	Type d’un élément.

Fonction membre	Description
`collection_adapter::base`	Désigne l’interface BCL encapsulée.
`collection_adapter::begin`	Désigne le début de la séquence contrôlée.
`collection_adapter::collection_adapter`	Construit un objet adaptateur.
`collection_adapter::end`	Désigne la fin de la séquence contrôlée.
`collection_adapter::size`	Compte le nombre d'éléments.
`collection_adapter::swap`	Échange le contenu de deux conteneurs.

Opérateur	Description
`collection_adapter::operator=`	Remplace le handle BCL stocké.

Notes

Vous utilisez cette classe de modèle pour manipuler un conteneur BCL en tant que conteneur STL/CLR. Le collection_adapter handle stocke un handle sur une interface BCL, qui contrôle à son tour une séquence d’éléments. Un collection_adapter objet X retourne une paire d’itérateurs X.begin() d’entrée et X.end() que vous utilisez pour visiter les éléments, dans l’ordre. Certaines spécialisations vous permettent également d’écrire X.size() pour déterminer la longueur de la séquence contrôlée.

`collection_adapter::base`

Désigne l’interface BCL encapsulée.

Syntaxe

Coll^ base();

Notes

La fonction membre retourne le handle d’interface BCL stocké.

Exemple

// cliext_collection_adapter_base.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
    {
    cliext::deque<wchar_t> d6x(6, L'x');
    Mycoll c1(%d6x);

    // display initial contents "x x x x x x "
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("base() same = {0}", c1.base() == %c1);
    return (0);
    }

x x x x x x
base() same = True

`collection_adapter::begin`

Désigne le début de la séquence contrôlée.

Syntaxe

iterator begin();

Notes

La fonction membre retourne un itérateur d’entrée qui désigne le premier élément de la séquence contrôlée, ou juste au-delà de la fin d’une séquence vide.

Exemple

// cliext_collection_adapter_begin.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
{
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');
    Mycoll c1(%d1);

    // display initial contents "a b c "
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Mycoll::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);
    return (0);
}

a b c
*begin() = a
*++begin() = b

`collection_adapter::collection_adapter`

Construit un objet adaptateur.

Syntaxe

collection_adapter();
collection_adapter(collection_adapter<Coll>% right);
collection_adapter(collection_adapter<Coll>^ right);
collection_adapter(Coll^ collection);

Paramètres

collection
Handle BCL à encapsuler.

right
Objet à copier.

Notes

Constructeur :

collection_adapter();

initialise le handle stocké avec nullptr.

Constructeur :

collection_adapter(collection_adapter<Coll>% right);

initialise le handle stocké avec right.base().

Constructeur :

collection_adapter(collection_adapter<Coll>^ right);

initialise le handle stocké avec right->base().

Constructeur :

collection_adapter(Coll^ collection);

initialise le handle stocké avec collection.

Exemple

// cliext_collection_adapter_construct.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
{
    cliext::deque<wchar_t> d6x(6, L'x');

    // construct an empty container
    Mycoll c1;
    System::Console::WriteLine("base() null = {0}", c1.base() == nullptr);

    // construct with a handle
    Mycoll c2(%d6x);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    Mycoll c3(c2);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying a container handle
    Mycoll c4(%c3);
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
}

base() null = True
x x x x x x
x x x x x x
x x x x x x

`collection_adapter::difference_type`

Types d’une distance signée entre deux éléments.

Syntaxe

typedef int difference_type;

Notes

Le type décrit un nombre d’éléments signés.

Exemple

// cliext_collection_adapter_difference_type.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
{
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');
    Mycoll c1(%d1);

    // display initial contents "a b c "
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    Mycoll::difference_type diff = 0;
    Mycoll::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
}

a b c
end()-begin() = 3

`collection_adapter::end`

Désigne la fin de la séquence contrôlée.

Syntaxe

iterator end();

Notes

La fonction membre retourne un itérateur d’entrée qui pointe juste au-delà de la fin de la séquence contrôlée.

Exemple

// cliext_collection_adapter_end.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
{
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');
    Mycoll c1(%d1);

    // display initial contents "a b c "
    Mycoll::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
}

a b c

`collection_adapter::iterator`

Type d'un itérateur pour la séquence contrôlée.

Syntaxe

typedef T1 iterator;

Notes

Le type décrit un objet de type T1 non spécifié qui peut servir d’itérateur d’entrée pour la séquence contrôlée.

Exemple

// cliext_collection_adapter_iterator.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
{
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');
    Mycoll c1(%d1);

    // display initial contents "a b c "
    Mycoll::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
}

a b c

`collection_adapter::key_type`

Type d’une clé de dictionnaire.

Syntaxe

typedef Key key_type;

Notes

Le type est un synonyme du paramètre Keyde modèle , dans une spécialisation pour IDictionary ou IDictionary<Value>; sinon, il n’est pas défini.

Exemple

// cliext_collection_adapter_key_type.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
typedef cliext::collection_adapter<
    System::Collections::Generic::IDictionary<wchar_t, int>> Mycoll;
typedef System::Collections::Generic::KeyValuePair<wchar_t,int> Mypair;
int main()
{
    Mymap d1;
    d1.insert(Mymap::make_value(L'a', 1));
    d1.insert(Mymap::make_value(L'b', 2));
    d1.insert(Mymap::make_value(L'c', 3));
    Mycoll c1(%d1);

    // display contents "[a 1] [b 2] [c 3] "
    for each (Mypair elem in c1)
    {
        Mycoll::key_type key = elem.Key;
        Mycoll::mapped_type value = elem.Value;
        System::Console::Write("[{0} {1}] ", key, value);
    }
    System::Console::WriteLine();
    return (0);
}

[a 1] [b 2] [c 3]

`collection_adapter::mapped_type`

Type d’une valeur de dictionnaire.

Syntaxe

typedef Value mapped_type;

Notes

Le type est un synonyme du paramètre Valuede modèle , dans une spécialisation pour IDictionary ou IDictionary<Value>; sinon, il n’est pas défini.

Exemple

// cliext_collection_adapter_mapped_type.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
typedef cliext::collection_adapter<
    System::Collections::Generic::IDictionary<wchar_t, int>> Mycoll;
typedef System::Collections::Generic::KeyValuePair<wchar_t,int> Mypair;
int main()
{
    Mymap d1;
    d1.insert(Mymap::make_value(L'a', 1));
    d1.insert(Mymap::make_value(L'b', 2));
    d1.insert(Mymap::make_value(L'c', 3));
    Mycoll c1(%d1);

    // display contents "[a 1] [b 2] [c 3] "
    for each (Mypair elem in c1)
    {
        Mycoll::key_type key = elem.Key;
        Mycoll::mapped_type value = elem.Value;
        System::Console::Write("[{0} {1}] ", key, value);
    }
    System::Console::WriteLine();
    return (0);
}

[a 1] [b 2] [c 3]

`collection_adapter::operator=`

Remplace le handle BCL stocké.

Syntaxe

collection_adapter<Coll>% operator=(collection_adapter<Coll>% right);

Paramètres

right
Adaptateur à copier.

Notes

L’opérateur membre copie right dans l’objet, puis retourne *this. Vous l’utilisez pour remplacer le handle BCL stocké par une copie du handle BCL stocké dans right.

Exemple

// cliext_collection_adapter_operator_as.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
{
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');
    Mycoll c1(%d1);

    // display initial contents "a b c "
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    Mycoll c2;
    c2 = c1;
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
a b c

`collection_adapter::reference`

Type d'une référence à un élément.

Syntaxe

typedef value_type% reference;

Notes

Le type décrit une référence à un élément.

Exemple

// cliext_collection_adapter_reference.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
    {
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');
    Mycoll c1(%d1);

    // display initial contents "a b c "
    Mycoll::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
    {   // get a reference to an element
        Mycoll::reference ref = *it;
        System::Console::Write("{0} ", ref);
    }
    System::Console::WriteLine();
    return (0);
}

a b c

`collection_adapter::size`

Compte le nombre d'éléments.

Syntaxe

size_type size();

Notes

La fonction membre retourne la longueur de la séquence contrôlée. Elle n’est pas définie dans une spécialisation pour IEnumerable ou IEnumerable<Value>.

Exemple

// cliext_collection_adapter_size.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
{
    cliext::deque<wchar_t> d6x(6, L'x');
    Mycoll c1(%d6x);

    // display initial contents "x x x x x x "
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
}

x x x x x x
size() = 6

`collection_adapter::size_type`

Type d'une distance signée entre deux éléments.

Syntaxe

typedef int size_type;

Notes

Le type décrit un nombre d’éléments non négatifs.

Exemple

// cliext_collection_adapter_size_type.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
{
    cliext::deque<wchar_t> d6x(6, L'x');
    Mycoll c1(%d6x);

    // display initial contents "x x x x x x"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    Mycoll::size_type size = c1.size();
    System::Console::WriteLine("size() = {0}", size);
    return (0);
}

x x x x x x
size() = 6

`collection_adapter::swap`

Échange le contenu de deux conteneurs.

Syntaxe

void swap(collection_adapter<Coll>% right);

Paramètres

right
Conteneur avec lequel échanger le contenu.

Notes

La fonction membre échange les handles BCL stockés entre *this et right.

Exemple

// cliext_collection_adapter_swap.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
{
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');
    Mycoll c1(%d1);

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct another container with repetition of values
    cliext::deque<wchar_t> d2(5, L'x');
    Mycoll c2(%d2);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
x x x x x
x x x x x
a b c

`collection_adapter::value_type`

Type d’un élément.

Syntaxe

typedef Value value_type;

Notes

Le type est un synonyme du paramètre Valuede modèle, s’il est présent dans la spécialisation ; sinon, il s’agit d’un synonyme pour System::Object^.

Exemple

// cliext_collection_adapter_value_type.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
{
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');
    Mycoll c1(%d1);

    // display contents "a b c" using value_type
    for (Mycoll::iterator it = c1.begin();
        it != c1.end(); ++it)
    {   // store element in value_type object
        Mycoll::value_type val = *it;

        System::Console::Write("{0} ", val);
    }
    System::Console::WriteLine();
    return (0);
}

a b c

make_collection (STL/CLR)

Créez une range_adapter paire d’itérateurs.

Syntaxe

template<typename Iter>
    range_adapter<Iter> make_collection(Iter first, Iter last);

Paramètres

Iter
Type des itérateurs encapsulés.

first
Tout d’abord, itérateur à encapsuler.

last
Deuxième itérateur à encapsuler.

Notes

Le modèle de fonction retourne gcnew range_adapter<Iter>(first, last). Vous l’utilisez pour construire un range_adapter<Iter> objet à partir d’une paire d’itérateurs.

Exemple

// cliext_make_collection.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::deque<wchar_t> Mycont;
typedef cliext::range_adapter<Mycont::iterator> Myrange;
int main()
{
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in d1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Collections::ICollection^ p1 =
        cliext::make_collection(d1.begin(), d1.end());
    System::Console::WriteLine("Count = {0}", p1->Count);
    System::Console::WriteLine("IsSynchronized = {0}",
        p1->IsSynchronized);
    System::Console::WriteLine("SyncRoot not nullptr = {0}",
        p1->SyncRoot != nullptr);

    // copy the sequence
    cli::array<System::Object^>^ a1 = gcnew cli::array<System::Object^>(5);

    a1[0] = L'|';
    p1->CopyTo(a1, 1);
    a1[4] = L'|';
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
}

a b c
Count = 3
IsSynchronized = False
SyncRoot not nullptr = True
| a b c |

range_adapter (STL/CLR)

Classe de modèle qui encapsule une paire d’itérateurs utilisés pour implémenter plusieurs interfaces BCL (Base Class Library). Vous utilisez le range_adapter pour manipuler une plage STL/CLR comme s’il s’agissait d’une collection BCL.

Syntaxe

template<typename Iter>
    ref class range_adapter
        :   public
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<Value>,
        System::Collections::Generic::ICollection<Value>
    { ..... };

Paramètres

Iter
Type associé aux itérateurs encapsulés.

Membres

Fonction membre	Description
`range_adapter::range_adapter`	Construit un objet adaptateur.

Opérateur	Description
`range_adapter::operator=`	Remplace la paire itérateur stockée.

Interfaces

Interface	Description
IEnumerable	Itère au sein des éléments de la collection.
ICollection	Conserve un groupe d’éléments.
IEnumerable<T>	Itère au moyen d’éléments typés dans la collection.
ICollection<T>	Gère un groupe d’éléments typés.

Notes

Le range_adapter stocke une paire d’itérateurs, qui délimitent à leur tour une séquence d’éléments. L’objet implémente quatre interfaces BCL qui vous permettent d’itérer au sein des éléments, dans l’ordre. Vous utilisez cette classe de modèle pour manipuler des plages STL/CLR comme des conteneurs BCL.

`range_adapter::operator=`

Remplace la paire itérateur stockée.

Syntaxe

range_adapter<Iter>% operator=(range_adapter<Iter>% right);

Paramètres

right
Adaptateur à copier.

Notes

L’opérateur membre copie right dans l’objet, puis retourne *this. Vous l’utilisez pour remplacer la paire itérateur stockée par une copie de la paire itérateur stockée dans right.

Exemple

// cliext_range_adapter_operator_as.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::deque<wchar_t> Mycont;
typedef cliext::range_adapter<Mycont::iterator> Myrange;
int main()
{
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');
    Myrange c1(d1.begin(), d1.end());

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    Myrange c2;
    c2 = c1;
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
a b c

`range_adapter::range_adapter`

Construit un objet adaptateur.

Syntaxe

range_adapter();
range_adapter(range_adapter<Iter>% right);
range_adapter(range_adapter<Iter>^ right);
range_adapter(Iter first, Iter last);

Paramètres

first
Tout d’abord, itérateur à encapsuler.

last
Deuxième itérateur à encapsuler.

right
Objet à copier.

Notes

Constructeur :

range_adapter();

initialise la paire itérateur stockée avec des itérateurs construits par défaut.

Constructeur :

range_adapter(range_adapter<Iter>% right);

initialise la paire itérateur stockée en copiant la paire stockée dans right.

Constructeur :

range_adapter(range_adapter<Iter>^ right);

initialise la paire itérateur stockée en copiant la paire stockée dans *right.

Constructeur :

range_adapter(Iter^ first, last);

initialise la paire itérateur stockée avec first et last.

Exemple

// cliext_range_adapter_construct.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::deque<wchar_t> Mycont;
typedef cliext::range_adapter<Mycont::iterator> Myrange;
int main()
{
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');

    // construct an empty adapter
    Myrange c1;

    // construct with an iterator pair
    Myrange c2(d1.begin(), d1.end());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another adapter
    Myrange c3(c2);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying an adapter handle
    Myrange c4(%c3);
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
}

a b c
a b c
a b c

Partager via

<cliext/adapter> (STL/CLR)

Syntaxe

Spécifications

Déclarations

Membres

collection_adapter

Syntaxe

Paramètres

Spécialisations

Membres

Notes

collection_adapter::base

Syntaxe

Notes

Exemple

collection_adapter::begin

Syntaxe

Notes

Exemple

collection_adapter::collection_adapter

Syntaxe

Paramètres

Notes

Exemple

collection_adapter::difference_type

Syntaxe

Notes

Exemple

collection_adapter::end

Syntaxe

Notes

Exemple

collection_adapter::iterator

Syntaxe

Notes

Exemple

collection_adapter::key_type

Syntaxe

Notes

Exemple

collection_adapter::mapped_type

Syntaxe

Notes

Exemple

collection_adapter::operator=

Syntaxe

Paramètres

Notes

Exemple

collection_adapter::reference

Syntaxe

Notes

Exemple

collection_adapter::size

Syntaxe

Notes

Exemple

collection_adapter::size_type

Syntaxe

Notes

Exemple

collection_adapter::swap

Syntaxe

Paramètres

Notes

Exemple

collection_adapter::value_type

Syntaxe

Notes

Exemple

make_collection (STL/CLR)

Syntaxe

Paramètres

Notes

Exemple

range_adapter (STL/CLR)

Syntaxe

Paramètres

Membres

`<cliext/adapter>` (STL/CLR)

`collection_adapter`

`collection_adapter::base`

`collection_adapter::begin`

`collection_adapter::collection_adapter`

`collection_adapter::difference_type`

`collection_adapter::end`

`collection_adapter::iterator`

`collection_adapter::key_type`

`collection_adapter::mapped_type`

`collection_adapter::operator=`

`collection_adapter::reference`

`collection_adapter::size`

`collection_adapter::size_type`

`collection_adapter::swap`

`collection_adapter::value_type`

`range_adapter::operator=`

`range_adapter::range_adapter`