vector (STL/CLR)

Artikel
10/12/2023

Die Vorlagenklasse beschreibt ein Objekt, das eine unterschiedliche Abfolge von Elementen steuert, die zufälligen Zugriff haben. Sie verwenden den Container vector , um eine Abfolge von Elementen als zusammenhängenden Speicherblock zu verwalten. Der Block wird als Array implementiert, das bei Bedarf wächst.

In der nachstehenden Beschreibung entspricht der Wert, es sei denn, GValue letzteres ist ein Bezugstyp, in diesem Fall ist Value^es .

Syntax

template<typename Value>
    ref class vector
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IVector<GValue>
    { ..... };

Parameter

Wert
Der Typ eines Elements in der kontrollierten Sequenz.

Anforderungen

Header:<cliext/vector>

Namespace: cliext

Deklarationen

Typendefinition	Beschreibung
vector::const_iterator (STL/CLR)	Der Typ eines konstanten Iterators für die gesteuerte Sequenz.
vector::const_reference (STL/CLR)	Der Typ eines konstanten Verweises auf ein Element.
vector::const_reverse_iterator (STL/CLR)	Der Typ eines konstanten umgekehrten Iterators für die gesteuerte Sequenz.
vector::difference_type (STL/CLR)	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
vector::generic_container (STL/CLR)	Der Typ der generischen Schnittstelle für den Container.
vector::generic_iterator (STL/CLR)	Der Typ eines Iterators für die generische Schnittstelle für den Container.
vector::generic_reverse_iterator (STL/CLR)	Der Typ eines Reverse iterators für die generische Schnittstelle für den Container.
vector::generic_value (STL/CLR)	Der Typ eines Elements für die generische Schnittstelle für den Container.
vector::iterator (STL/CLR)	Der Typ eines Iterators für die gesteuerte Sequenz.
vector::reference (STL/CLR)	Der Typ eines Verweises auf ein Element.
vector::reverse_iterator (STL/CLR)	Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.
vector::size_type (STL/CLR)	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
vector::value_type (STL/CLR)	Der Typ eines Elements.

Memberfunktion	Beschreibung
vector::assign (STL/CLR)	Ersetzt alle Elemente.
vector::at (STL/CLR)	Greift auf ein Element an einer angegebenen Position zu.
vector::back (STL/CLR)	Greift auf das letzte Element zu.
vector::begin (STL/CLR)	Legt den Anfang der kontrollierten Sequenz fest.
vector::capacity (STL/CLR)	Meldet die Größe des zugewiesenen Speichers für den Container.
vector::clear (STL/CLR)	Entfernt alle Elemente.
vector::empty (STL/CLR)	Testet, ob keine Elemente vorhanden sind.
vector::end (STL/CLR)	Legt das Ende der kontrollierten Sequenz fest.
vector::erase (STL/CLR)	Entfernt Elemente an den angegebenen Positionen.
vector::front (STL/CLR)	Greift auf das erste Element zu.
vector::insert (STL/CLR)	Fügt Elemente an einer angegebenen Position hinzu.
vector::pop_back (STL/CLR)	Entfernt das letzte Element.
vector::push_back (STL/CLR)	Fügt ein neues letztes Element hinzu.
vector::rbegin (STL/CLR)	Legt den Anfang der umgekehrten kontrollierten Sequenz fest.
vector::rend (STL/CLR)	Legt das Ende der umgekehrten kontrollierten Sequenz fest.
vector::reserve (STL/CLR)	Stellt eine minimale Wachstumskapazität für den Container sicher.
vector::resize (STL/CLR)	Ändert die Anzahl der Elemente.
vector::size (STL/CLR)	Ermittelt die Anzahl von Elementen.
vector::swap (STL/CLR)	Vertauscht den Inhalt von zwei Containern.
vector::to_array (STL/CLR)	Kopiert die kontrollierte Sequenz in ein neues Array.
vector::vector (STL/CLR)	Erstellt ein container-Objekt.

Eigenschaft	Beschreibung
vector::back_item (STL/CLR)	Greift auf das letzte Element zu.
vector::front_item (STL/CLR)	Greift auf das erste Element zu.

Operator	Beschreibung
vector::operator= (STL/CLR)	Ersetzt die kontrollierte Sequenz.
vector::operator(STL/CLR)	Greift auf ein Element an einer angegebenen Position zu.
operator!= (vector) (STL/CLR)	Bestimmt, ob ein Objekt nicht mit einem `vector` anderen `vector` Objekt identisch ist.
Operator< (Vektor) (STL/CLR)	Bestimmt, ob ein Objekt kleiner als ein `vector` anderes `vector` Objekt ist.
operator<= (Vektor) (STL/CLR)	Bestimmt, ob ein Objekt kleiner oder gleich einem `vector` anderen `vector` Objekt ist.
operator== (vector) (STL/CLR)	Bestimmt, ob ein Objekt mit einem `vector` anderen `vector` Objekt identisch ist.
Operator> (Vektor) (STL/CLR)	Bestimmt, ob ein Objekt größer als ein `vector` anderes `vector` Objekt ist.
operator>= (Vektor) (STL/CLR)	Bestimmt, ob ein Objekt größer oder gleich einem `vector` anderen `vector` Objekt ist.

Schnittstellen

Schnittstelle	Beschreibung
ICloneable	Duplizieren Eines Objekts.
IEnumerable	Sequenzieren durch Elemente.
ICollection	Verwalten sie eine Gruppe von Elementen.
IEnumerable<T>	Sequenz durch eingegebene Elemente.
ICollection<T>	Verwalten der Gruppe von typierten Elementen.
IList<T>	Verwalten Sie sortierte Gruppe von typierten Elementen.
IVector-Wert<>	Verwalten Sie generischen Container.

Hinweise

Das Objekt reserviert und gibt Speicherplatz für die Sequenz frei, die es über ein gespeichertes Array von Value-Elementen steuert, was bei Bedarf wächst. Das Wachstum erfolgt so, dass die Kosten für das Anfügen eines neuen Elements konstanter Zeit sind. Mit anderen Worten, die Kosten für das Hinzufügen von Elementen am Ende werden nicht erhöht, im Durchschnitt, da die Länge der kontrollierten Sequenz größer wird. Daher ist ein Vektor ein guter Kandidat für den zugrunde liegenden Container für Vorlagenklassenstapel (STL/CLR).

A vector supports random-access iterators, which means you can refer to an element directly given its numer position, counting from zero for the first (front) element, to size() - 1 the last (back) element. Dies bedeutet auch, dass ein Vektor ein guter Kandidat für den zugrunde liegenden Container für Vorlagenklasse priority_queue (STL/CLR) ist.

Ein Vektor-Iterator speichert ein Handle für das zugeordnete Vektorobjekt zusammen mit der Verzerrung des von ihm definierten Elements. Sie können Iteratoren nur mit den zugehörigen Containerobjekten verwenden. Die Verzerrung eines Vektorelements entspricht der Position.

Das Einfügen oder Löschen von Elementen kann den an einer bestimmten Position gespeicherten Elementwert ändern, sodass sich der von einem Iterator festgelegte Wert auch ändern kann. (Möglicherweise muss der Container Elemente nach oben oder unten kopieren, um ein Loch vor dem Einfügen zu erstellen oder ein Loch nach einem Radierer zu füllen.) Dennoch bleibt ein Vektor-Iterator gültig, solange sich seine Verzerrung im Bereich [0, size()]befindet. Darüber hinaus bleibt ein gültiger Iterator ableitend – Sie können ihn verwenden, um auf den von ihm angegebenen Elementwert zuzugreifen oder ihn zu ändern – solange seine Verzerrung nicht gleich size()ist.

Beim Löschen oder Entfernen eines Elements wird der Destruktor für den gespeicherten Wert aufgerufen. Durch das Zerstören des Containers werden alle Elemente gelöscht. Daher stellt ein Container, dessen Elementtyp eine Ref-Klasse ist, sicher, dass keine Elemente den Container überleben. Beachten Sie jedoch, dass ein Container mit Ziehpunkten seine Elemente nicht zerstört.

Member

vector::assign (STL/CLR)

Ersetzt alle Elemente.

Syntax

void assign(size_type count, value_type val);
template<typename InIt>
    void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);

Parameter

count
Die Anzahl einzufügender Elemente.

first
Anfang des einzufügenden Bereichs.

last
Ende des einzufügenden Bereichs.

right
Einzufügende Aufzählung.

val
Wert des einzufügenden Elements.

Hinweise

Die erste Memberfunktion ersetzt die kontrollierte Sequenz durch eine Wiederholung von Anzahlelementen von Wertwertwert. Sie verwenden ihn, um den Container mit Elementen zu füllen, die denselben Wert aufweisen.

Wenn InIt es sich um einen ganzzahligen Typ handelt, verhält sich die zweite Memberfunktion wie assign((size_type)first, (value_type)last). Andernfalls ersetzt sie die kontrollierte Sequenz durch die Sequenz [first, last). Sie verwenden sie, um die kontrollierte Sequenz zu einer anderen Sequenz zu machen.

Die dritte Memberfunktion ersetzt die gesteuerte Sequenz durch die sequenz, die durch das Enumeratorrecht festgelegt ist. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer Sequenz zu machen, die von einem Enumerator beschrieben wird.

Beispiel

// cliext_vector_assign.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// assign a repetition of values
    cliext::vector<wchar_t> c2;
    c2.assign(6, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign an iterator range
    c2.assign(c1.begin(), c1.end() - 1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign an enumeration
    c2.assign(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

x x x x x x
a b
a b c

vector::at (STL/CLR)

Greift auf ein Element an einer angegebenen Position zu.

Syntax

reference at(size_type pos);

Parameter

pos
Position des Elements, auf das zugegriffen wird

Hinweise

Die Memberfunktion gibt einen Verweis auf das Element der gesteuerten Sequenz an Position pos zurück. Sie verwenden es, um ein Element zu lesen oder zu schreiben, dessen Position Sie kennen.

Beispiel

// cliext_vector_at.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c" using at
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

// change an entry and redisplay
    c1.at(1) = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

vector::back (STL/CLR)

Greift auf das letzte Element zu.

Syntax

reference back();

Hinweise

Die Memberfunktion gibt einen Verweis auf das letzte Element der gesteuerten Sequenz zurück, die nicht leer sein muss. Sie verwenden es, um auf das letzte Element zuzugreifen, wenn Sie wissen, dass es vorhanden ist.

Beispiel

// cliext_vector_back.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// inspect last item
    System::Console::WriteLine("back() = {0}", c1.back());

// alter last item and reinspect
    c1.back() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back() = c
a b x

vector::back_item (STL/CLR)

Greift auf das letzte Element zu.

Syntax

property value_type back_item;

Hinweise

Die Eigenschaft greift auf das letzte Element der gesteuerten Sequenz zu, die nicht leer sein muss. Sie verwenden es, um das letzte Element zu lesen oder zu schreiben, wenn Sie wissen, dass es vorhanden ist.

Beispiel

// cliext_vector_back_item.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// inspect last item
    System::Console::WriteLine("back_item = {0}", c1.back_item);

// alter last item and reinspect
    c1.back_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back_item = c
a b x

vector::begin (STL/CLR)

Legt den Anfang der kontrollierten Sequenz fest.

Syntax

iterator begin();

Hinweise

Die Memberfunktion gibt einen Iterator mit wahlfreiem Zugriff zurück, der das erste Element der kontrollierten Sequenz oder direkt über das Ende einer leeren Sequenz bestimmt. Sie verwenden es, um einen Iterator zu erhalten, der den current Anfang der kontrollierten Sequenz angibt, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_vector_begin.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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
    cliext::vector<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);

// alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

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

vector::capacity (STL/CLR)

Meldet die Größe des zugewiesenen Speichers für den Container.

Syntax

size_type capacity();

Hinweise

Die Memberfunktion gibt den zurzeit zugewiesenen Speicher für die kontrollierte Sequenz zurück, einen Wert mindestens so groß wie vector::size (STL/CLR)(). Sie verwenden ihn, um zu bestimmen, wie viel der Container wachsen kann, bevor der Speicher für die kontrollierte Sequenz neu zugeordnet werden muss.

Beispiel

// cliext_vector_capacity.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

// increase capacity
    cliext::vector<wchar_t>::size_type cap = c1.capacity();
    System::Console::WriteLine("capacity() = {0}, ok = {1}",
        cap, c1.size() <= cap);
    c1.reserve(cap + 5);
    System::Console::WriteLine("capacity() = {0}, ok = {1}",
        c1.capacity(), cap + 5 <= c1.capacity());
    return (0);
    }

a b c
capacity() = 4, ok = True
capacity() = 9, ok = True

vector::clear (STL/CLR)

Entfernt alle Elemente.

Syntax

void clear();

Hinweise

Die Memberfunktion ruft effektiv vector::erase (STL/CLR)( vector::begin (STL/CLR)(), vector::end (STL/CLR) auf.()) Sie verwenden es, um sicherzustellen, dass die kontrollierte Sequenz leer ist.

Beispiel

// cliext_vector_clear.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

// add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

vector::const_iterator (STL/CLR)

Der Typ eines konstanten Iterators für die gesteuerte Sequenz.

Syntax

typedef T2 const_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T2 , das als konstanter Iterator für den zufälligen Zugriff für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_vector_const_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    cliext::vector<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

vector::const_reference (STL/CLR)

Der Typ eines konstanten Verweises auf ein Element.

Syntax

typedef value_type% const_reference;

Hinweise

Der Typ beschreibt einen Konstantenverweis auf ein Element.

Beispiel

// cliext_vector_const_reference.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    cliext::vector<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        cliext::vector<wchar_t>::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

vector::const_reverse_iterator (STL/CLR)

Der Typ einer Konstantenumkehr iterator für die kontrollierte Sequenz..

Syntax

typedef T4 const_reverse_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T4 , das als konstanten Reverse iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_vector_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c" reversed
    cliext::vector<wchar_t>::const_reverse_iterator crit = c1.rbegin();
    cliext::vector<wchar_t>::const_reverse_iterator crend = c1.rend();
    for (; crit != crend; ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

vector::difference_type (STL/CLR)

Die Typen eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int difference_type;

Hinweise

Der Typ beschreibt eine signierte Elementanzahl.

Beispiel

// cliext_vector_difference_type.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

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

// compute negative difference
    diff = 0;
    for (cliext::vector<wchar_t>::iterator it = c1.end();
        it != c1.begin(); --it) --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

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

vector::empty (STL/CLR)

Testet, ob keine Elemente vorhanden sind.

Syntax

bool empty();

Hinweise

Die Memberfunktion gibt „true“ für eine leere gesteuerte Sequenz zurück. Es entspricht Vektor::size (STL/CLR)() == 0. Sie verwenden es, um zu testen, ob der Vektor leer ist.

Beispiel

// cliext_vector_empty.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

a b c
size() = 3
empty() = False
size() = 0
empty() = True

vector::end (STL/CLR)

Legt das Ende der kontrollierten Sequenz fest.

Syntax

iterator end();

Hinweise

Die Memberfunktion gibt einen Iterator mit zufälligem Zugriff zurück, der unmittelbar über das Ende der kontrollierten Sequenz verweist. Sie verwenden es, um einen Iterator zu erhalten, der das current Ende der kontrollierten Sequenz angibt, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_vector_end.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// inspect last two items
    cliext::vector<wchar_t>::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);

// alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --end() = b
*--end() = c
a x y

vector::erase (STL/CLR)

Entfernt Elemente an den angegebenen Positionen.

Syntax

iterator erase(iterator where);
iterator erase(iterator first, iterator last);

Parameter

first
Anfang des zu löschenden Bereichs.

last
Ende des zu löschenden Bereichs.

where
Element, das gelöscht werden soll.

Hinweise

Die erste Memberfunktion entfernt das Element der kontrollierten Sequenz, auf die durch die Stelle verwiesen wird. Sie verwenden es, um ein einzelnes Element zu entfernen.

Die zweite Memberfunktion entfernt die Elemente der gesteuerten Sequenz im Bereich [first, last). Sie verwenden es, um null oder mehr zusammenhängende Elemente zu entfernen.

Beide Memberfunktionen geben einen Iterator zurück, der das erste Element angibt, das über alle entfernten Elemente hinausgeht, oder vector::end (STL/CLR),() wenn kein solches Element vorhanden ist.

Beim Löschen von Elementen ist die Anzahl der Elementkopien linear in der Anzahl der Elemente zwischen dem Ende der Löschung und dem näheren Ende der Sequenz. (Beim Löschen eines oder mehrerer Elemente am Ende der Sequenz treten keine Elementkopien auf.)

Beispiel

// cliext_vector_erase.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

// add elements and display " b c d e"
    c1.push_back(L'd');
    c1.push_back(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// erase all but end
    cliext::vector<wchar_t>::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

vector::front (STL/CLR)

Greift auf das erste Element zu.

Syntax

reference front();

Hinweise

Die Memberfunktion gibt einen Verweis auf das erste Element der kontrollierten Sequenz zurück, die nicht leer sein muss. Sie verwenden es, um das erste Element zu lesen oder zu schreiben, wenn Sie wissen, dass es vorhanden ist.

Beispiel

// cliext_vector_front.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// inspect first item
    System::Console::WriteLine("front() = {0}", c1.front());

// alter first item and reinspect
    c1.front() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front() = a
x b c

vector::front_item (STL/CLR)

Greift auf das erste Element zu.

Syntax

property value_type front_item;

Hinweise

Die Eigenschaft greift auf das erste Element der gesteuerten Sequenz zu, die nicht leer sein muss. Sie verwenden es, um das erste Element zu lesen oder zu schreiben, wenn Sie wissen, dass es vorhanden ist.

Beispiel

// cliext_vector_front_item.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// inspect first item
    System::Console::WriteLine("front_item = {0}", c1.front_item);

// alter first item and reinspect
    c1.front_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front_item = a
x b c

vector::generic_container (STL/CLR)

Der Typ der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::
    IVector<generic_value>
    generic_container;

Hinweise

Der Typ beschreibt die generische Schnittstelle für diese Vorlagencontainerklasse.

Beispiel

// cliext_vector_generic_container.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// construct a generic container
    cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify generic and display original
    gc1->insert(gc1->end(), L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify original and display generic
    c1.push_back(L'e');

    System::Collections::IEnumerator^ enum1 =
        gc1->GetEnumerator();
    while (enum1->MoveNext())
        System::Console::Write("{0} ", enum1->Current);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

vector::generic_iterator (STL/CLR)

Der Typ eines Iterators für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerRandomAccessIterator<generic_value>
    generic_iterator;

Hinweise

Der Typ beschreibt einen generischen Iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.

Beispiel

// cliext_vector_generic_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// construct a generic container
    cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify generic and display original
    cliext::vector<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::vector<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

vector::generic_reverse_iterator (STL/CLR)

Der Typ eines Reverse iterators für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value> generic_reverse_iterator;

Hinweise

Der Typ beschreibt einen generischen Reverse iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.

Beispiel

// cliext_vector_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// construct a generic container
    cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify generic and display original
    cliext::vector<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
    cliext::vector<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a c c

vector::generic_value (STL/CLR)

Der Typ eines Elements für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef GValue generic_value;

Hinweise

Der Typ beschreibt ein Objekt vom Typ GValue , das den gespeicherten Elementwert für die Verwendung mit der generischen Schnittstelle für diese Vorlagencontainerklasse beschreibt.

Beispiel

// cliext_vector_generic_value.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// construct a generic container
    cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify generic and display original
    cliext::vector<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::vector<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

vector::insert (STL/CLR)

Fügt Elemente an einer angegebenen Position hinzu.

Syntax

iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
    void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
    System::Collections::Generic::IEnumerable<Value>^ right);

Parameter

count
Die Anzahl einzufügender Elemente.

first
Anfang des einzufügenden Bereichs.

last
Ende des einzufügenden Bereichs.

right
Einzufügende Aufzählung.

val
Wert des einzufügenden Elements.

where
Position im Container, der zuvor eingefügt werden soll.

Hinweise

Jede der Memberfunktionen fügt vor dem Element, auf das in der gesteuerten Sequenz verwiesen wird, eine durch die verbleibenden Operanden angegebene Sequenz ein.

Die erste Memberfunktion fügt ein Element mit Wertwert ein und gibt einen Iterator zurück, der das neu eingefügte Element angibt. Sie verwenden es, um ein einzelnes Element vor einer von einem Iterator festgelegten Stelle einzufügen.

Die zweite Memberfunktion fügt eine Wiederholung von Anzahlelementen von Wertwertwert ein. Sie verwenden sie, um null oder mehr zusammenhängende Elemente einzufügen, die alle Kopien desselben Werts sind.

Wenn InIt ein Ganzzahltyp ist, verhält sich die dritte Memberfunktion genau wie insert(where, (size_type)first, (value_type)last). Andernfalls wird die Sequenz [first, last) eingefügt. Sie verwenden sie, um null oder mehr zusammenhängende Elemente einzufügen, die aus einer anderen Sequenz kopiert wurden.

Die vierte Memberfunktion fügt die von der rechten Seite festgelegte Sequenz ein. Sie verwenden sie, um eine von einem Enumerator beschriebene Sequenz einzufügen.

Beim Einfügen eines einzelnen Elements ist die Anzahl der Elementkopien linear in der Anzahl der Elemente zwischen der Einfügemarke und dem näheren Ende der Sequenz. (Beim Einfügen eines oder mehrerer Elemente am Ende der Sequenz treten keine Elementkopien auf.) Wenn InIt es sich um einen Eingabe-Iterator handelt, führt die dritte Memberfunktion effektiv eine einzelne Einfügung für jedes Element in der Sequenz durch. Andernfalls ist N beim Einfügen N von Elementen die Anzahl der Elementkopien linear und die Anzahl der Elemente zwischen der Einfügemarke und dem näheren Ende der Sequenz.

Beispiel

// cliext_vector_insert.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// insert a single value using iterator
    cliext::vector<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("insert(begin()+1, L'x') = {0}",
        *c1.insert(++it, L'x'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert a repetition of values
    cliext::vector<wchar_t> c2;
    c2.insert(c2.begin(), 2, L'y');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert an iterator range
    it = c1.end();
    c2.insert(c2.end(), c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert an enumeration
    c2.insert(c2.begin(),   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(begin()+1, L'x') = x
a x b c
y y
y y a x b
a x b c y y a x b

vector::iterator (STL/CLR)

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 Zufallszugriffs-Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_vector_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c"
    cliext::vector<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();

// alter first element and redisplay
    it = c1.begin();
    *it = L'x';
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c
x b c

vector::operator= (STL/CLR)

Ersetzt die kontrollierte Sequenz.

Syntax

vector<Value>% operator=(vector<Value>% right);

Parameter

right
Der zu kopierende Container.

Hinweise

Der Memberoperator kopiert direkt in das Objekt und gibt dann zurück *this. Sie verwenden sie, um die kontrollierte Sequenz durch eine Kopie der gesteuerten Sequenz rechts zu ersetzen.

Beispiel

// cliext_vector_operator_as.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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
    cliext::vector<wchar_t> 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

vector::operator(STL/CLR)

Greift auf ein Element an einer angegebenen Position zu.

Syntax

reference operator[](size_type pos);

Parameter

pos
Position des Elements, auf das zugegriffen wird

Hinweise

Der Memberoperator gibt einen Verweis auf das Element an position pos. Sie verwenden es, um auf ein Element zuzugreifen, dessen Position Sie kennen.

Beispiel

// cliext_vector_operator_sub.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c" using subscripting
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();

// change an entry and redisplay
    c1[1] = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

vector::pop_back (STL/CLR)

Entfernt das letzte Element.

Syntax

void pop_back();

Hinweise

Die Memberfunktion entfernt das letzte Element der gesteuerten Sequenz, das nicht leer sein muss. Sie verwenden sie, um den Vektor um ein Element im Hintergrund zu kürzen.

Beispiel

// cliext_vector_pop_back.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// pop an element and redisplay
    c1.pop_back();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b

vector::push_back (STL/CLR)

Fügt ein neues letztes Element hinzu.

Syntax

void push_back(value_type val);

Hinweise

Die Memberfunktion fügt ein Element mit Dem Wert val am Ende der gesteuerten Sequenz ein. Sie verwenden es, um ein anderes Element an den Vektor anzufügen.

Beispiel

// cliext_vector_push_back.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

a b c

vector::rbegin (STL/CLR)

Legt den Anfang der umgekehrten kontrollierten Sequenz fest.

Syntax

reverse_iterator rbegin();

Hinweise

Die Memberfunktion gibt einen Umgekehrten Iterator zurück, der das letzte Element der gesteuerten Sequenz oder direkt hinter dem Anfang einer leeren Sequenz angibt. Daher wird die beginning umgekehrte Sequenz festgelegt. Sie verwenden es, um einen Iterator zu erhalten, der den current Anfang der kontrollierten Sequenz angibt, die in umgekehrter Reihenfolge angezeigt wird, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_vector_rbegin.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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 in reversed sequence
    cliext::vector<wchar_t>::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);

// alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b
a y x

vector::reference (STL/CLR)

Der Typ eines Verweises auf ein Element.

Syntax

typedef value_type% reference;

Hinweise

Der Typ beschreibt einen Verweis auf ein Element.

Beispiel

// cliext_vector_reference.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// modify contents " a b c"
    for (it = c1.begin(); it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::vector<wchar_t>::reference ref = *it;

        ref += (wchar_t)(L'A' - L'a');
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c
A B C

vector::rend (STL/CLR)

Legt das Ende der umgekehrten kontrollierten Sequenz fest.

Syntax

reverse_iterator rend();

Hinweise

Die Memberfunktion gibt einen Umgekehrten Iterator zurück, der unmittelbar über den Anfang der gesteuerten Sequenz verweist. Daher wird die end umgekehrte Sequenz festgelegt. Sie verwenden es, um einen Iterator zu erhalten, der das current Ende der kontrollierten Sequenz angibt, die in umgekehrter Reihenfolge angezeigt wird, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_vector_rend.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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
    cliext::vector<wchar_t>::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);

// alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a
y x c

vector::reserve (STL/CLR)

Stellt eine minimale Wachstumskapazität für den Container sicher.

Syntax

void reserve(size_type count);

Parameter

count
Neue Mindestkapazität des Containers.

Hinweise

Die Memberfunktion stellt sicher, dass capacity() daher mindestens anzahl zurückgegeben wird. Sie verwenden es, um sicherzustellen, dass der Container keine Speicherzuweisung für die kontrollierte Sequenz benötigt, bis er auf die angegebene Größe gewachsen ist.

Beispiel

// cliext_vector_reserve.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display initial contents " a b c"
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

// increase capacity
    cliext::vector<wchar_t>::size_type cap = c1.capacity();
    System::Console::WriteLine("capacity() = {0}, ok = {1}",
        cap, c1.size() <= cap);
    c1.reserve(cap + 5);
    System::Console::WriteLine("capacity() = {0}, ok = {1}",
        c1.capacity(), cap + 5 <= c1.capacity());
    return (0);
    }

a b c
capacity() = 4, ok = True
capacity() = 9, ok = True

vector::resize (STL/CLR)

Ändert die Anzahl der Elemente.

Syntax

void resize(size_type new_size);
void resize(size_type new_size, value_type val);

Parameter

new_size
Neue Größe der gesteuerten Sequenz.

val
Wert des Abstandselements.

Hinweise

Die Memberfunktionen stellen sicher, dass Vektor::size (STL/CLR)() daher new_size zurückgibt. Wenn die kontrollierte Sequenz länger sein muss, fügt die erste Memberfunktion Elemente mit Wert value_type()an, während die zweite Memberfunktion Elemente mit Wertwert anfüge. Um die kontrollierte Sequenz zu verkürzen, löschen beide Memberfunktionen effektiv die letzten Elementvektor ::size (STL/CLR)-() - new_size Zeiten. Sie verwenden es, um sicherzustellen, dass die kontrollierte Sequenz größe new_size hat, indem Sie entweder die aktuelle kontrollierte Sequenz kürzen oder auffüllen.

Beispiel

// cliext_vector_resize.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
// construct an empty container and pad with default values
    cliext::vector<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());
    c1.resize(4);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

// resize to empty
    c1.resize(0);
    System::Console::WriteLine("size() = {0}", c1.size());

// resize and pad
    c1.resize(5, L'x');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
0 0 0 0
size() = 0
x x x x x

vector::reverse_iterator (STL/CLR)

Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.

Syntax

typedef T3 reverse_iterator;

Hinweise

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

Beispiel

// cliext_vector_reverse_iterator.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// display contents " a b c" reversed
    cliext::vector<wchar_t>::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();

// alter first element and redisplay
    rit = c1.rbegin();
    *rit = L'x';
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a
x b a

vector::size (STL/CLR)

Ermittelt die Anzahl von Elementen.

Syntax

size_type size();

Hinweise

Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück. Sie verwenden es, um die Anzahl der Elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befindet. Wenn Sie sich nur darum kümmern, ob die Sequenz eine Nichtzerogröße aufweist, lesen Sie vector::empty (STL/CLR)().

Beispiel

// cliext_vector_size.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

// add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

vector::size_type (STL/CLR)

Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.

Syntax

typedef int size_type;

Hinweise

Der Typ beschreibt eine nicht negative Elementanzahl.

Beispiel

// cliext_vector_size_type.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

// compute positive difference
    cliext::vector<wchar_t>::size_type diff = c1.end() - c1.begin();
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

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

vector::swap (STL/CLR)

Vertauscht den Inhalt von zwei Containern.

Syntax

void swap(vector<Value>% right);

Parameter

right
Container für den Tausch von Inhalten.

Hinweise

Die Memberfunktion wechselt die gesteuerten Sequenzen zwischen *this und rechts. Dies geschieht in konstanter Zeit und löst keine Ausnahmen aus. Sie verwenden es als schnelle Möglichkeit, den Inhalt von zwei Containern auszutauschen.

Beispiel

// cliext_vector_swap.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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::vector<wchar_t> c2(5, L'x');
    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

vector::to_array (STL/CLR)

Kopiert die kontrollierte Sequenz in ein neues Array.

Syntax

cli::array<Value>^ to_array();

Hinweise

Die Memberfunktion gibt ein Array zurück, das die kontrollierte Sequenz enthält. Sie verwenden es, um eine Kopie der kontrollierten Sequenz in Arrayform abzurufen.

Beispiel

// cliext_vector_to_array.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.push_back(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

vector::value_type (STL/CLR)

Der Typ eines Elements.

Syntax

typedef Value value_type;

Hinweise

Der Typ ist ein Synonym für den Vorlagenparameter Value.

Beispiel

// cliext_vector_value_type.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

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

a b c

vector::vector (STL/CLR)

Erstellt ein container-Objekt.

Syntax

vector();
vector(vector<Value>% right);
vector(vector<Value>^ right);
explicit vector(size_type count);
vector(size_type count, value_type val);
template<typename InIt>
    vector(InIt first, InIt last);
vector(System::Collections::Generic::IEnumerable<Value>^ right);

Parameter

count
Die Anzahl einzufügender Elemente.

first
Anfang des einzufügenden Bereichs.

last
Ende des einzufügenden Bereichs.

right
Einzufügendes Objekt bzw. einzufügender Bereich.

val
Wert des einzufügenden Elements.

Hinweise

Der Konstruktor:

vector();

initialisiert die kontrollierte Sequenz ohne Elemente. Sie verwenden sie, um eine leere anfängliche kontrollierte Sequenz anzugeben.

Der Konstruktor:

vector(vector<Value>% right);

initialisiert die kontrollierte Sequenz mit der Sequenz [right.begin(), right.end()). Sie verwenden sie, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der Sequenz ist, die vom Vektorobjekt rechts gesteuert wird.

Der Konstruktor:

vector(vector<Value>^ right);

initialisiert die kontrollierte Sequenz mit der Sequenz [right->begin(), right->end()). Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der Sequenz ist, die vom Vektorobjekt gesteuert wird, dessen Handle rechts ist.

Der Konstruktor:

explicit vector(size_type count);

initialisiert die kontrollierte Sequenz mit Zählungselementen mit jedem Wert value_type(). Sie verwenden ihn, um den Container mit Elementen zu füllen, die alle den Standardwert aufweisen.

Der Konstruktor:

vector(size_type count, value_type val);

initialisiert die kontrollierte Sequenz mit Zählungselementen , die jeweils einen Wertwert aufweisen. Sie verwenden ihn, um den Container mit Elementen zu füllen, die denselben Wert aufweisen.

Der Konstruktor:

template<typename InIt>

vector(InIt first, InIt last);

initialisiert die kontrollierte Sequenz mit der Sequenz [first, last). Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen.

Der Konstruktor:

vector(System::Collections::Generic::IEnumerable<Value>^ right);

initialisiert die kontrollierte Sequenz mit der Sequenz, die vom Enumerator rechts festgelegt ist. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen, die von einem Enumerator beschrieben wird.

Beispiel

// cliext_vector_construct.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
// construct an empty container
    cliext::vector<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());

// construct with a repetition of default values
    cliext::vector<wchar_t> c2(3);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

// construct with a repetition of values
    cliext::vector<wchar_t> c3(6, L'x');
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an iterator range
    cliext::vector<wchar_t>::iterator it = c3.end();
    cliext::vector<wchar_t> c4(c3.begin(), --it);
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an enumeration
    cliext::vector<wchar_t> c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct by copying another container
    cliext::vector<wchar_t> c7(c3);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct by copying a container handle
    cliext::vector<wchar_t> c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
    }

size() = 0
0 0 0
x x x x x x
x x x x x
x x x x x x
x x x x x x
x x x x x x

operator!= (vector) (STL/CLR)

Vektor nicht gleich Vergleich.

Syntax

template<typename Value>
    bool operator!=(vector<Value>% left,
        vector<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(left == right). Sie verwenden sie, um zu testen, ob links nicht gleich geordnet ist wie rechts , wenn die beiden Vektoren elementweise verglichen werden.

Beispiel

// cliext_vector_operator_ne.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

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

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True

`operator<` (Vektor) (STL/CLR)

Vektor kleiner als vergleich.

Syntax

template<typename Value>
    bool operator<(vector<Value>% left,
        vector<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt true zurück, wenn, für die niedrigste Positioni, für die !(right[i] < left[i]) sie auch wahr ist.left[i] < right[i] Andernfalls gibt left->size() < right->size() sie zurück. Sie verwenden sie, um zu testen, ob links vor rechts sortiert ist, wenn die beiden Vektoren Element nach Element verglichen werden.

Beispiel

// cliext_vector_operator_lt.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

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

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True

`operator<=` (Vektor) (STL/CLR)

Vektor kleiner oder gleich vergleich.

Syntax

template<typename Value>
    bool operator<=(vector<Value>% left,
        vector<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(right < left). Sie verwenden es, um zu testen, ob links nach rechts nicht sortiert ist, wenn die beiden Vektoren elementweise verglichen werden.

Beispiel

// cliext_vector_operator_le.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

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

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

operator== (vector) (STL/CLR)

Vektorgleicher Vergleich.

Syntax

template<typename Value>
    bool operator==(vector<Value>% left,
        vector<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt "true" nur zurück, wenn die von links und rechts gesteuerten Sequenzen dieselbe Länge und für jede Position left[i] == right[i]idie gleiche Länge aufweisen. Sie verwenden es, um zu testen, ob links gleich geordnet ist wie rechts , wenn die beiden Vektoren Element nach Element verglichen werden.

Beispiel

// cliext_vector_operator_eq.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

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

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False

`operator>` (Vektor) (STL/CLR)

Vektor größer als vergleich.

Syntax

template<typename Value>
    bool operator>(vector<Value>% left,
        vector<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück right < left. Sie verwenden es, um zu testen, ob links nach rechts sortiert wird, wenn die beiden Vektoren elementnach Element verglichen werden.

Beispiel

// cliext_vector_operator_gt.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

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

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True

`operator>=` (Vektor) (STL/CLR)

Vektor größer oder gleich vergleicht.

Syntax

template<typename Value>
    bool operator>=(vector<Value>% left,
        vector<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(left < right). Sie verwenden es, um zu testen, ob links nicht vor rechts angeordnet ist, wenn die beiden Vektoren elementweise verglichen werden.

Beispiel

// cliext_vector_operator_ge.cpp
// compile with: /clr
#include <cliext/vector>

int main()
    {
    cliext::vector<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

// 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
    cliext::vector<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

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

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False

Freigeben über

vector (STL/CLR)

Syntax

Parameter

Anforderungen

Deklarationen

Schnittstellen

Hinweise

Member

vector::assign (STL/CLR)

Syntax

Parameter

Hinweise

Beispiel

vector::at (STL/CLR)

Syntax

Parameter

Hinweise

Beispiel

vector::back (STL/CLR)

Syntax

Hinweise

Beispiel

vector::back_item (STL/CLR)

Syntax

Hinweise

Beispiel

vector::begin (STL/CLR)

Syntax

Hinweise

Beispiel

vector::capacity (STL/CLR)

Syntax

Hinweise

Beispiel

vector::clear (STL/CLR)

Syntax

Hinweise

Beispiel

vector::const_iterator (STL/CLR)

Syntax

Hinweise

Beispiel

vector::const_reference (STL/CLR)

Syntax

Hinweise

Beispiel

vector::const_reverse_iterator (STL/CLR)

Syntax

Hinweise

Beispiel

vector::difference_type (STL/CLR)

Syntax

Hinweise

Beispiel

vector::empty (STL/CLR)

Syntax

Hinweise

Beispiel

vector::end (STL/CLR)

Syntax

Hinweise

Beispiel

vector::erase (STL/CLR)

Syntax

Parameter

Hinweise

Beispiel

vector::front (STL/CLR)

Syntax

Hinweise

Beispiel

vector::front_item (STL/CLR)

Syntax

Hinweise

Beispiel

vector::generic_container (STL/CLR)

Syntax

Hinweise

Beispiel