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

Artikel
10/12/2023

Der STL/CLR-Header <cliext/adapter> gibt zwei Klassenvorlagen (collection_adapter und range_adapter) und die Funktionsvorlage make_collectionan.

Syntax

#include <cliext/adapter>

Anforderungen

Header:<cliext/adapter>

Namespace:cliext

Deklarationen

Klasse	Beschreibung
`collection_adapter`	Umschließt die BCL-Auflistung (Base Class Library) als Bereich.
`range_adapter`	Umschließt den Bereich als BCL-Auflistung.

Funktion	Beschreibung
`make_collection`	Erstellt einen Bereichsadapter mit einem Iteratorpaar.

Member

`collection_adapter`

Umschließt eine .NET-Auflistung für die Verwendung als STL/CLR-Container. A collection_adapter ist eine Vorlagenklasse, die ein einfaches STL/CLR-Containerobjekt beschreibt. Sie umschließt eine BCL-Schnittstelle (Base Class Library) und gibt ein Iteratorpaar zurück, das Sie zum Bearbeiten der gesteuerten Sequenz verwenden.

Syntax

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

Parameter

Coll
Der Typ der umschlossenen Auflistung.

Spezialisierungen

spezialisierung	Beschreibung
`IEnumerable`	Sequenziert durch Elemente.
`ICollection`	Verwaltet eine Gruppe von Elementen.
`IList`	Verwaltet eine sortierte Gruppe von Elementen.
`IDictionary`	Verwalten Sie eine Gruppe von {key,value}-Paaren.
`IEnumerable<Value>`	Sequenzen durch typierte Elemente.
`ICollection<Value>`	Verwaltet eine Gruppe von typierten Elementen.
`IList<Value>`	Verwaltet eine sortierte Gruppe von typierten Elementen.
`IDictionary<Value>`	Verwaltet einen Satz von typierten {key,value}-Paaren.

Member

Typdefinition	Beschreibung
`collection_adapter::difference_type`	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
`collection_adapter::iterator`	Der Typ eines Iterators für die gesteuerte Sequenz.
`collection_adapter::key_type`	Der Typ eines Wörterbuchschlüssels.
`collection_adapter::mapped_type`	Der Typ eines Wörterbuchwerts.
`collection_adapter::reference`	Der Typ eines Verweises auf ein Element.
`collection_adapter::size_type`	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
`collection_adapter::value_type`	Der Typ eines Elements.

Memberfunktion	Beschreibung
`collection_adapter::base`	Legt die umschlossene BCL-Schnittstelle fest.
`collection_adapter::begin`	Legt den Anfang der kontrollierten Sequenz fest.
`collection_adapter::collection_adapter`	Erstellt ein Adapterobjekt.
`collection_adapter::end`	Legt das Ende der kontrollierten Sequenz fest.
`collection_adapter::size`	Ermittelt die Anzahl von Elementen.
`collection_adapter::swap`	Vertauscht den Inhalt von zwei Containern.

Operator	Beschreibung
`collection_adapter::operator=`	Ersetzt das gespeicherte BCL-Handle.

Hinweise

Sie verwenden diese Vorlagenklasse, um einen BCL-Container als STL/CLR-Container zu bearbeiten. Im collection_adapter Speicher wird ein Handle für eine BCL-Schnittstelle gespeichert, die wiederum eine Abfolge von Elementen steuert. Ein collection_adapter Objekt X gibt ein Eingabe-Iteratorpaar X.begin() zurück, das X.end() Sie verwenden, um die Elemente in der Reihenfolge zu besuchen. Einige der Spezialisierungen ermöglichen es Ihnen X.size() auch, die Länge der kontrollierten Sequenz zu bestimmen.

`collection_adapter::base`

Legt die umschlossene BCL-Schnittstelle fest.

Syntax

Coll^ base();

Hinweise

Die Memberfunktion gibt das gespeicherte BCL-Schnittstellenhandle zurück.

Beispiel

// 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`

Legt den Anfang der kontrollierten Sequenz fest.

Syntax

iterator begin();

Hinweise

Die Memberfunktion gibt einen Eingabe-Iterator zurück, der das erste Element der gesteuerten Sequenz oder direkt über das Ende einer leeren Sequenz bestimmt.

Beispiel

// 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`

Erstellt ein Adapterobjekt.

Syntax

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

Parameter

collection
BCL-Handle zum Umbrechen.

right
Objekt, das kopiert werden soll.

Hinweise

Der Konstruktor:

collection_adapter();

initialisiert das gespeicherte Handle mit nullptr.

Der Konstruktor:

collection_adapter(collection_adapter<Coll>% right);

initialisiert das gespeicherte Handle mit right.base().

Der Konstruktor:

collection_adapter(collection_adapter<Coll>^ right);

initialisiert das gespeicherte Handle mit right->base().

Der Konstruktor:

collection_adapter(Coll^ collection);

initialisiert das gespeicherte Handle mit collection.

Beispiel

// 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`

Die Typen eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int difference_type;

Hinweise

Der Typ beschreibt eine signierte Elementanzahl.

Beispiel

// 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`

Legt das Ende der kontrollierten Sequenz fest.

Syntax

iterator end();

Hinweise

Die Memberfunktion gibt einen Eingabe-Iterator zurück, der unmittelbar über das Ende der gesteuerten Sequenz verweist.

Beispiel

// 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`

Der Typ eines Iterators für die gesteuerte Sequenz.

Syntax

typedef T1 iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T1 , das als Eingabe-Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// 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`

Der Typ eines Wörterbuchschlüssels.

Syntax

typedef Key key_type;

Hinweise

Der Typ ist ein Synonym für den Vorlagenparameter Key, in einer Spezialisierung für IDictionary oder IDictionary<Value>; andernfalls ist er nicht definiert.

Beispiel

// 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`

Der Typ eines Wörterbuchwerts.

Syntax

typedef Value mapped_type;

Hinweise

Der Typ ist ein Synonym für den Vorlagenparameter Value, in einer Spezialisierung für IDictionary oder IDictionary<Value>; andernfalls ist er nicht definiert.

Beispiel

// 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=`

Ersetzt das gespeicherte BCL-Handle.

Syntax

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

Parameter

right
Adapter, der kopiert werden soll.

Hinweise

Der Memberoperator kopiert right in das Objekt und gibt dann zurück *this. Sie verwenden es, um den gespeicherten BCL-Handle durch eine Kopie des gespeicherten BCL-Handles zu rightersetzen.

Beispiel

// 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`

Der Typ eines Verweises auf ein Element.

Syntax

typedef value_type% reference;

Hinweise

Der Typ beschreibt einen Verweis auf ein Element.

Beispiel

// 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`

Ermittelt die Anzahl von Elementen.

Syntax

size_type size();

Hinweise

Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück. Es ist nicht in einer Spezialisierung für IEnumerable oder IEnumerable<Value>.

Beispiel

// 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`

Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.

Syntax

typedef int size_type;

Hinweise

Der Typ beschreibt eine nicht negative Elementanzahl.

Beispiel

// 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`

Vertauscht den Inhalt von zwei Containern.

Syntax

void swap(collection_adapter<Coll>% right);

Parameter

right
Container für den Tausch von Inhalten.

Hinweise

Die Memberfunktion tauscht die gespeicherten BCL-Handles zwischen *this und right.

Beispiel

// 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`

Der Typ eines Elements.

Syntax

typedef Value value_type;

Hinweise

Der Typ ist ein Synonym für den Vorlagenparameter Value, wenn er in der Spezialisierung vorhanden ist; andernfalls ist er ein Synonym für System::Object^.

Beispiel

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

Erstellen Sie ein range_adapter Iteratorpaar.

Syntax

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

Parameter

Iter
Der Typ des umschlossenen Iterators.

first
Erster Iterator, der umbrochen werden soll.

last
Second iterator to wrap.

Hinweise

Die Funktionsvorlage gibt zurück gcnew range_adapter<Iter>(first, last). Sie verwenden es, um ein range_adapter<Iter> Objekt aus einem Iteratorpaar zu konstruieren.

Beispiel

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

Eine Vorlagenklasse, die ein Paar Iteratoren umschließt, die zum Implementieren mehrerer BCL-Schnittstellen (Base Class Library) verwendet werden. Sie verwenden die range_adapter, um einen STL/CLR-Bereich so zu bearbeiten, als ob es sich um eine BCL-Auflistung handelte.

Syntax

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

Parameter

Iter
Der Typ, der den umschlossenen Iteratoren zugeordnet ist.

Member

Memberfunktion	Beschreibung
`range_adapter::range_adapter`	Erstellt ein Adapterobjekt.

Operator	Beschreibung
`range_adapter::operator=`	Ersetzt das gespeicherte Iteratorpaar.

Schnittstellen

Schnittstelle	Beschreibung
IEnumerable	Durchläuft Elemente in der Auflistung.
ICollection	Verwaltet eine Gruppe von Elementen.
IEnumerable<T>	Durchläuft typierte Elemente in der Auflistung.
ICollection<T>	Verwaltet eine Gruppe von typierten Elementen.

Hinweise

Die range_adapter speichert ein Iteratorpaar, das wiederum eine Abfolge von Elementen abgrenzt. Das Objekt implementiert vier BCL-Schnittstellen, mit denen Sie die Elemente durchlaufen können, in der reihenfolge. Sie verwenden diese Vorlagenklasse, um STL/CLR-Bereiche ähnlich wie BCL-Container zu bearbeiten.

`range_adapter::operator=`

Ersetzt das gespeicherte Iteratorpaar.

Syntax

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

Parameter

right
Adapter, der kopiert werden soll.

Hinweise

Der Memberoperator kopiert right in das Objekt und gibt dann zurück *this. Sie verwenden es, um das gespeicherte Iteratorpaar durch eine Kopie des gespeicherten Iteratorpaars in right.

Beispiel

// 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`

Erstellt ein Adapterobjekt.

Syntax

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

Parameter

first
Erster Iterator, der umbrochen werden soll.

last
Second iterator to wrap.

right
Objekt, das kopiert werden soll.

Hinweise

Der Konstruktor:

range_adapter();

initialisiert das gespeicherte Iteratorpaar mit standardmäßig konstruierten Iteratoren.

Der Konstruktor:

range_adapter(range_adapter<Iter>% right);

initialisiert das gespeicherte Iteratorpaar durch Kopieren des in right.

Der Konstruktor:

range_adapter(range_adapter<Iter>^ right);

initialisiert das gespeicherte Iteratorpaar durch Kopieren des in *right.

Der Konstruktor:

range_adapter(Iter^ first, last);

initialisiert das gespeicherte Iteratorpaar mit first und last.

Beispiel

// 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

Freigeben über

<cliext/adapter> (STL/CLR)

Syntax

Anforderungen

Deklarationen

Member

collection_adapter

Syntax

Parameter

Spezialisierungen

Member

Hinweise

collection_adapter::base

Syntax

Hinweise

Beispiel

collection_adapter::begin

Syntax

Hinweise

Beispiel

collection_adapter::collection_adapter

Syntax

Parameter

Hinweise

Beispiel

collection_adapter::difference_type

Syntax

Hinweise

Beispiel

collection_adapter::end

Syntax

Hinweise

Beispiel

collection_adapter::iterator

Syntax

Hinweise

Beispiel

collection_adapter::key_type

Syntax

Hinweise

Beispiel

collection_adapter::mapped_type

Syntax

Hinweise

Beispiel

collection_adapter::operator=

Syntax

Parameter

Hinweise

Beispiel

collection_adapter::reference

Syntax

Hinweise

Beispiel

collection_adapter::size

Syntax

Hinweise

Beispiel

collection_adapter::size_type

Syntax

Hinweise

Beispiel

collection_adapter::swap

Syntax

Parameter

Hinweise

Beispiel

collection_adapter::value_type

Syntax

Hinweise

Beispiel

make_collection (STL/CLR)

Syntax

Parameter

Hinweise

Beispiel

range_adapter (STL/CLR)

Syntax

Parameter

Member

`<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`