vector (STL/CLR)

Artikel
02/04/2025

In de sjabloonklasse wordt een object beschreven waarmee een wisselende reeks elementen met willekeurige toegang wordt bestuurd. U gebruikt de container vector om een reeks elementen te beheren als een aaneengesloten blok opslag. Het blok wordt geïmplementeerd als een matrix die op aanvraag groeit.

In de onderstaande beschrijving is GValue hetzelfde als waarde, tenzij de laatste een verwijzingstype is, in dat geval Value^.

Syntaxis

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>
    { ..... };

Parameters

waarde
Het type element in de gecontroleerde reeks.

Eisen

koptekst:<cliext/vector>

naamruimte: cliext

Verklaringen

Typedefinitie	Beschrijving
vector::const_iterator (STL/CLR)	Het type van een constante iterator voor de gecontroleerde reeks.
vector::const_reference (STL/CLR)	Het type constante verwijzing naar een element.
vector::const_reverse_iterator (STL/CLR)	Het type van een constante omgekeerde iterator voor de gecontroleerde reeks.
vector::d ifference_type (STL/CLR)	Het type ondertekende afstand tussen twee elementen.
vector::generic_container (STL/CLR)	Het type van de algemene interface voor de container.
vector::generic_iterator (STL/CLR)	Het type iterator voor de algemene interface voor de container.
vector::generic_reverse_iterator (STL/CLR)	Het type omgekeerde iterator voor de algemene interface voor de container.
vector::generic_value (STL/CLR)	Het type element voor de algemene interface voor de container.
vector::iterator (STL/CLR)	Het type iterator voor de gecontroleerde reeks.
vector::reference (STL/CLR)	Het type verwijzing naar een element.
vector::reverse_iterator (STL/CLR)	Het type omgekeerde iterator voor de gecontroleerde reeks.
vector::size_type (STL/CLR)	Het type ondertekende afstand tussen twee elementen.
vector::value_type (STL/CLR)	Het type element.

Lid, functie	Beschrijving
vector::assign (STL/CLR)	Vervangt alle elementen.
vector::at (STL/CLR)	Krijgt toegang tot een element op een opgegeven positie.
vector::back (STL/CLR)	Hiermee opent u het laatste element.
vector::begin (STL/CLR)	Geeft het begin van de gecontroleerde reeks aan.
vector::capacity (STL/CLR)	Rapporteert de grootte van de toegewezen opslag voor de container.
vector::clear (STL/CLR)	Hiermee verwijdert u alle elementen.
vector::empty (STL/CLR)	Test of er geen elementen aanwezig zijn.
vector::end (STL/CLR)	Geeft het einde van de gecontroleerde reeks aan.
vector::gum (STL/CLR)	Hiermee verwijdert u elementen op opgegeven posities.
vector::front (STL/CLR)	Hiermee opent u het eerste element.
vector::insert (STL/CLR)	Voegt elementen toe op een opgegeven positie.
vector::p op_back (STL/CLR)	Hiermee verwijdert u het laatste element.
vector::p ush_back (STL/CLR)	Hiermee voegt u een nieuw laatste element toe.
vector::rbegin (STL/CLR)	Geeft het begin van de omgekeerde gecontroleerde reeks aan.
vector::rend (STL/CLR)	Hiermee wordt het einde van de omgekeerde gecontroleerde reeks aangeduid.
vector::reserve (STL/CLR)	Zorgt voor een minimale groeicapaciteit voor de container.
vector::resize (STL/CLR)	Hiermee wijzigt u het aantal elementen.
vector::size (STL/CLR)	Telt het aantal elementen.
vector::swap (STL/CLR)	Hiermee wordt de inhoud van twee containers gewisseld.
vector::to_array (STL/CLR)	Hiermee kopieert u de gecontroleerde reeks naar een nieuwe matrix.
vector::vector (STL/CLR)	Maakt een containerobject.

Eigenschap	Beschrijving
vector::back_item (STL/CLR)	Hiermee opent u het laatste element.
vector::front_item (STL/CLR)	Hiermee opent u het eerste element.

Bediener	Beschrijving
vector::operator= (STL/CLR)	Vervangt de gecontroleerde volgorde.
vector::operator(STL/CLR)	Krijgt toegang tot een element op een opgegeven positie.
operator!= (vector) (STL/CLR)	Bepaalt of een `vector` object niet gelijk is aan een ander `vector` object.
operator< (vector) (STL/CLR)	Bepaalt of een `vector` object kleiner is dan een ander `vector` object.
operator<= (vector) (STL/CLR)	Bepaalt of een `vector` object kleiner is dan of gelijk is aan een ander `vector` object.
operator== (vector) (STL/CLR)	Bepaalt of een `vector` object gelijk is aan een ander `vector`-object.
operator> (vector) (STL/CLR)	Bepaalt of een `vector` object groter is dan een ander `vector` object.
operator>= (vector) (STL/CLR)	Bepaalt of een `vector` object groter is dan of gelijk is aan een ander `vector` object.

Interfaces

Interface	Beschrijving
ICloneable	Een object dupliceren.
IEnumerable	Sequentieer door elementen.
ICollection	Groep elementen behouden.
IEnumerable<T>	Sequentieer door getypte elementen.
ICollection<T>	Groep getypte elementen onderhouden.
IList<T>	Geordende groep getypte elementen onderhouden.
IVector<waarde>	Algemene container onderhouden.

Opmerkingen

Het object wijst opslag toe en maakt opslag vrij voor de volgorde die het beheert via een opgeslagen matrix van Waarde elementen, die op aanvraag toenemen. De groei treedt op zodanige wijze op dat de kosten voor het toevoegen van een nieuw element constante tijd worden afgeschreven. Met andere woorden, de kosten van het toevoegen van elementen aan het einde nemen niet toe, gemiddeld, omdat de lengte van de gecontroleerde reeks groter wordt. Een vector is dus een goede kandidaat voor de onderliggende container voor sjabloonklasse stack (STL/CLR).

Een vector ondersteunt iterators voor willekeurige toegang, wat betekent dat u rechtstreeks naar een element kunt verwijzen op basis van de numerieke positie, waarbij wordt geteld van nul voor het eerste (voorste) element tot size() - 1 voor het laatste (achter)element. Het betekent ook dat een vector een goede kandidaat is voor de onderliggende container voor sjabloonklasse priority_queue (STL/CLR).

Een vector-iterator slaat een ingang op aan het bijbehorende vectorobject, samen met de vooroordelen van het element dat het aanwijst. U kunt iterators alleen gebruiken met de bijbehorende containerobjecten. De vooroordelen van een vectorelement zijn hetzelfde als de positie ervan.

Als u elementen invoegt of verwijdert, kan de elementwaarde die op een bepaalde positie is opgeslagen, wijzigen, zodat de waarde die door een iterator is aangewezen, ook kan worden gewijzigd. (Mogelijk moet de container elementen omhoog of omlaag kopiëren om een gat te maken voor een invoeging of om een gat te vullen na een gum.) Toch blijft een vector-iterator geldig zolang de vooroordelen in het bereik [0, size()]. Bovendien blijft een geldige iterator deferenceerbaar - u kunt deze gebruiken om toegang te krijgen tot of de aan te wijzen elementwaarde te wijzigen - zolang de vooroordelen niet gelijk zijn aan size().

Door een element te wissen of te verwijderen, wordt de destructor voor de opgeslagen waarde aanroepen. Als u de container vernietigt, worden alle elementen gewist. Een container waarvan het elementtype een verw-klasse is, zorgt er dus voor dat geen elementen de container overleeft. Houd er echter rekening mee dat een container met ingangen de elementen niet vernietigt.

Leden

vector::assign (STL/CLR)

Vervangt alle elementen.

Syntaxis

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

Parameters

aantal
Aantal elementen dat moet worden ingevoegd.

eerste
Begin van het bereik dat moet worden ingevoegd.

laatste
Einde van het bereik dat moet worden ingevoegd.

Opsomming die moet worden ingevoegd.

val-
De waarde van het element dat moet worden ingevoegd.

Opmerkingen

De eerste lidfunctie vervangt de gecontroleerde reeks door een herhaling van aantal elementen van waarde val. U gebruikt deze om de container te vullen met elementen die allemaal dezelfde waarde hebben.

Als InIt een geheel getal is, gedraagt de tweede lidfunctie zich hetzelfde als assign((size_type)first, (value_type)last). Anders wordt de gecontroleerde reeks vervangen door de reeks [first, last). U gebruikt deze om de gecontroleerde reeks een andere reeks te maken.

De derde lidfunctie vervangt de gecontroleerde reeks door de reeks die is aangewezen door de enumerator rechter. U gebruikt deze om de gecontroleerde volgorde een kopie te maken van een reeks die wordt beschreven door een enumerator.

Voorbeeld

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

Krijgt toegang tot een element op een opgegeven positie.

Syntaxis

reference at(size_type pos);

Parameters

pos
Positie van element voor toegang.

Opmerkingen

De lidfunctie retourneert een verwijzing naar het element van de gecontroleerde reeks op positie pos. U gebruikt het om een element te lezen of te schrijven waarvan u de positie kent.

Voorbeeld

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

Hiermee opent u het laatste element.

Syntaxis

reference back();

Opmerkingen

De lidfunctie retourneert een verwijzing naar het laatste element van de gecontroleerde reeks, die niet leeg moet zijn. U gebruikt het om toegang te krijgen tot het laatste element wanneer u weet dat het bestaat.

Voorbeeld

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

Hiermee opent u het laatste element.

Syntaxis

property value_type back_item;

Opmerkingen

De eigenschap heeft toegang tot het laatste element van de gecontroleerde reeks, die niet leeg moet zijn. U gebruikt het om het laatste element te lezen of te schrijven, wanneer u weet dat het bestaat.

Voorbeeld

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

Geeft het begin van de gecontroleerde reeks aan.

Syntaxis

iterator begin();

Opmerkingen

De lidfunctie retourneert een iterator voor willekeurige toegang die het eerste element van de gecontroleerde reeks aanwijst, of net voorbij het einde van een lege reeks. U gebruikt deze om een iterator te verkrijgen die het current begin van de gecontroleerde reeks aanwijst, maar de status ervan kan veranderen als de lengte van de gecontroleerde reeks verandert.

Voorbeeld

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

Rapporteert de grootte van de toegewezen opslag voor de container.

Syntaxis

size_type capacity();

Opmerkingen

De lidfunctie retourneert de opslag die momenteel is toegewezen voor het opslaan van de gecontroleerde reeks, een waarde die minstens zo groot is als vector::size (STL/CLR)(). U gebruikt deze om te bepalen hoeveel de container kan groeien voordat de opslag voor de gecontroleerde reeks opnieuw moet worden geïmplementeerd.

Voorbeeld

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

Hiermee verwijdert u alle elementen.

Syntaxis

void clear();

Opmerkingen

De lidfunctie roept in feite vector::gum (STL/CLR)(vector::begin (STL/CLR)(),vector::end (STL/CLR)()). U gebruikt deze om ervoor te zorgen dat de gecontroleerde volgorde leeg is.

Voorbeeld

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

Het type van een constante iterator voor de gecontroleerde reeks.

Syntaxis

typedef T2 const_iterator;

Opmerkingen

Het type beschrijft een object van niet-opgegeven type T2 dat kan fungeren als een constante iterator voor willekeurige toegang voor de gecontroleerde reeks.

Voorbeeld

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

Het type constante verwijzing naar een element.

Syntaxis

typedef value_type% const_reference;

Opmerkingen

Het type beschrijft een constante verwijzing naar een element.

Voorbeeld

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

Het type van een constante omgekeerde iterator voor de gecontroleerde reeks.

Syntaxis

typedef T4 const_reverse_iterator;

Opmerkingen

Het type beschrijft een object van niet-opgegeven type T4 dat kan fungeren als een constante omgekeerde iterator voor de gecontroleerde reeks.

Voorbeeld

// 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::d ifference_type (STL/CLR)

De typen van een ondertekende afstand tussen twee elementen.

Syntaxis

typedef int difference_type;

Opmerkingen

Het type beschrijft het aantal ondertekende elementen.

Voorbeeld

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

Test of er geen elementen aanwezig zijn.

Syntaxis

bool empty();

Opmerkingen

De lidfunctie retourneert waar voor een lege beheerde reeks. Het is gelijk aan vector::size (STL/CLR)() == 0. U gebruikt deze om te testen of de vector leeg is.

Voorbeeld

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

Geeft het einde van de gecontroleerde reeks aan.

Syntaxis

iterator end();

Opmerkingen

De lidfunctie retourneert een iterator voor willekeurige toegang die net buiten het einde van de gecontroleerde reeks wijst. U gebruikt deze om een iterator te verkrijgen die het current einde van de gecontroleerde reeks aanwijst, maar de status ervan kan veranderen als de lengte van de gecontroleerde reeks verandert.

Voorbeeld

// 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::gum (STL/CLR)

Hiermee verwijdert u elementen op opgegeven posities.

Syntaxis

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

Parameters

eerste
Begin van bereik om te wissen.

laatste
Einde van bereik dat moet worden gewist.

waar
Element dat moet worden gewist.

Opmerkingen

De eerste lidfunctie verwijdert het element van de gecontroleerde reeks waarnaar wordt verwezen door waar. U gebruikt dit om één element te verwijderen.

De tweede lidfunctie verwijdert de elementen van de gecontroleerde reeks in het bereik [first, last). U gebruikt het om nul of meer aaneengesloten elementen te verwijderen.

Beide lidfuncties retourneren een iterator die het eerste element aanwijst dat buiten alle verwijderde elementen valt of vector::end (STL/CLR)() als er geen dergelijk element bestaat.

Bij het wissen van elementen is het aantal elementkopieën lineair in het aantal elementen tussen het einde van de verwijdering en het dichtstbijzijnde einde van de reeks. (Bij het wissen van een of meer elementen aan een van beide uiteinden van de reeks, worden er geen elementkopieën weergegeven.)

Voorbeeld

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

Hiermee opent u het eerste element.

Syntaxis

reference front();

Opmerkingen

De lidfunctie retourneert een verwijzing naar het eerste element van de gecontroleerde reeks, die niet leeg moet zijn. U gebruikt het om het eerste element te lezen of te schrijven, wanneer u weet dat het bestaat.

Voorbeeld

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

Hiermee opent u het eerste element.

Syntaxis

property value_type front_item;

Opmerkingen

De eigenschap heeft toegang tot het eerste element van de gecontroleerde reeks, die niet leeg moet zijn. U gebruikt het om het eerste element te lezen of te schrijven, wanneer u weet dat het bestaat.

Voorbeeld

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

Het type van de algemene interface voor de container.

Syntaxis

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

Opmerkingen

Het type beschrijft de algemene interface voor deze sjablooncontainerklasse.

Voorbeeld

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

Het type iterator voor gebruik met de algemene interface voor de container.

Syntaxis

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

Opmerkingen

Het type beschrijft een algemene iterator die kan worden gebruikt met de algemene interface voor deze sjablooncontainerklasse.

Voorbeeld

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

Het type omgekeerde iterator voor gebruik met de algemene interface voor de container.

Syntaxis

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

Opmerkingen

Het type beschrijft een algemene omgekeerde iterator die kan worden gebruikt met de algemene interface voor deze sjablooncontainerklasse.

Voorbeeld

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

Het type element dat moet worden gebruikt met de algemene interface voor de container.

Syntaxis

typedef GValue generic_value;

Opmerkingen

Het type beschrijft een object van het type GValue dat de waarde van het opgeslagen element beschrijft voor gebruik met de algemene interface voor deze sjablooncontainerklasse.

Voorbeeld

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

Voegt elementen toe op een opgegeven positie.

Syntaxis

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

Parameters

aantal
Aantal elementen dat moet worden ingevoegd.

eerste
Begin van het bereik dat moet worden ingevoegd.

laatste
Einde van het bereik dat moet worden ingevoegd.

Opsomming die moet worden ingevoegd.

val-
De waarde van het element dat moet worden ingevoegd.

waar
Waar in de container moet worden ingevoegd.

Opmerkingen

Elk van de lidfuncties wordt ingevoegd, vóór het element waarnaar wordt verwezen door waar in de gecontroleerde volgorde, een reeks die is opgegeven door de resterende operanden.

Met de functie eerste lid wordt een element ingevoegd met de waarde val en wordt een iterator geretourneerd waarmee het zojuist ingevoegde element wordt aangewezen. U gebruikt dit om één element in te voegen voor een plaats die is aangewezen door een iterator.

Met de functie tweede lid wordt een herhaling ingevoegd van aantal elementen van waarde val. U gebruikt deze om nul of meer aaneengesloten elementen in te voegen die allemaal kopieën van dezelfde waarde zijn.

Als InIt een geheel getal is, gedraagt de functie van het derde lid zich hetzelfde als insert(where, (size_type)first, (value_type)last). Anders wordt de reeks [first, last) ingevoegd. U kunt deze gebruiken om nul of meer aaneengesloten elementen in te voegen die zijn gekopieerd uit een andere reeks.

Met de vierde lidfunctie wordt de volgorde ingevoegd die is aangewezen door de rechter. U gebruikt deze om een reeks in te voegen die wordt beschreven door een opsommingsprogramma.

Wanneer u één element invoegt, is het aantal kopieën van elementen lineair in het aantal elementen tussen de invoegpositie en het dichtstbijzijnde einde van de reeks. (Wanneer u een of meer elementen aan een van beide uiteinden van de reeks invoegt, worden er geen elementkopieën weergegeven.) Als InIt een invoer-iterator is, voert de derde lidfunctie effectief één invoeging uit voor elk element in de reeks. Als u N elementen invoegt, is het aantal kopieën van elementen lineair in N plus het aantal elementen tussen de invoegpositie en het dichtstbijzijnde einde van de reeks.

Voorbeeld

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

Het type iterator voor de gecontroleerde reeks.

Syntaxis

typedef T1 iterator;

Opmerkingen

Het type beschrijft een object van niet-opgegeven type T1 dat kan fungeren als een iterator voor willekeurige toegang voor de gecontroleerde reeks.

Voorbeeld

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

Vervangt de gecontroleerde volgorde.

Syntaxis

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

Parameters

Te kopiëren container.

Opmerkingen

De lidoperator kopieert rechter naar het object en retourneert vervolgens *this. U gebruikt deze om de gecontroleerde reeks te vervangen door een kopie van de gecontroleerde reeks in rechter.

Voorbeeld

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

Krijgt toegang tot een element op een opgegeven positie.

Syntaxis

reference operator[](size_type pos);

Parameters

pos
Positie van element voor toegang.

Opmerkingen

De lidoperator retourneert een verwijzing naar het element op positie pos. U gebruikt het om toegang te krijgen tot een element waarvan u de positie kent.

Voorbeeld

// 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::p op_back (STL/CLR)

Hiermee verwijdert u het laatste element.

Syntaxis

void pop_back();

Opmerkingen

De lidfunctie verwijdert het laatste element van de gecontroleerde reeks, die niet leeg moet zijn. U gebruikt deze om de vector met één element aan de achterkant te verkorten.

Voorbeeld

// 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::p ush_back (STL/CLR)

Hiermee voegt u een nieuw laatste element toe.

Syntaxis

void push_back(value_type val);

Opmerkingen

Met de lidfunctie wordt een element ingevoegd met waarde val aan het einde van de gecontroleerde reeks. U gebruikt het om een ander element toe te voegen aan de vector.

Voorbeeld

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

Geeft het begin van de omgekeerde gecontroleerde reeks aan.

Syntaxis

reverse_iterator rbegin();

Opmerkingen

De lidfunctie retourneert een omgekeerde iterator die het laatste element van de gecontroleerde reeks aanwijst, of net voorbij het begin van een lege reeks. Daarom wordt de beginning van de omgekeerde reeks aangewezen. U gebruikt deze om een iterator te verkrijgen die het current begin van de gecontroleerde reeks aanwijst in omgekeerde volgorde, maar de status ervan kan veranderen als de lengte van de gecontroleerde reeks verandert.

Voorbeeld

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

Het type verwijzing naar een element.

Syntaxis

typedef value_type% reference;

Opmerkingen

Het type beschrijft een verwijzing naar een element.

Voorbeeld

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

Hiermee wordt het einde van de omgekeerde gecontroleerde reeks aangeduid.

Syntaxis

reverse_iterator rend();

Opmerkingen

De lidfunctie retourneert een omgekeerde iterator die net buiten het begin van de gecontroleerde reeks wijst. Daarom wordt de end van de omgekeerde reeks aangewezen. U gebruikt deze om een iterator te verkrijgen die het current einde van de gecontroleerde reeks aanwijst die in omgekeerde volgorde wordt gezien, maar de status ervan kan veranderen als de lengte van de gecontroleerde reeks verandert.

Voorbeeld

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

Zorgt voor een minimale groeicapaciteit voor de container.

Syntaxis

void reserve(size_type count);

Parameters

aantal
Nieuwe minimale capaciteit van de container.

Opmerkingen

De lidfunctie zorgt ervoor dat capacity() vanaf nu ten minste aantalretourneert. U gebruikt deze om ervoor te zorgen dat de container geen opslag opnieuw hoeft toe te passen voor de beheerde reeks totdat deze is gegroeid tot de opgegeven grootte.

Voorbeeld

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

Hiermee wijzigt u het aantal elementen.

Syntaxis

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

Parameters

new_size
Nieuwe grootte van de gecontroleerde reeks.

val-
Waarde van het opvullingselement.

Opmerkingen

De lidfuncties zorgen ervoor dat vector::size (STL/CLR)() vanaf nu new_sizeretourneert. Als de gecontroleerde volgorde langer moet worden uitgevoerd, voegt de eerste lidfunctie elementen toe met waarde value_type(), terwijl de tweede lidfunctie elementen met waarde valtoevoegt. Om de gecontroleerde reeks korter te maken, wissen beide lidfuncties effectief het laatste element vector::size (STL/CLR)() -new_size keer. U gebruikt deze om ervoor te zorgen dat de gecontroleerde reeks de grootte new_sizeheeft, door de huidige gecontroleerde reeks te knippen of op te vullingen.

Voorbeeld

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

Het type omgekeerde iterator voor de gecontroleerde reeks.

Syntaxis

typedef T3 reverse_iterator;

Opmerkingen

Het type beschrijft een object van niet-opgegeven type T3 dat kan fungeren als een omgekeerde iterator voor de gecontroleerde reeks.

Voorbeeld

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

Telt het aantal elementen.

Syntaxis

size_type size();

Opmerkingen

De lidfunctie retourneert de lengte van de gecontroleerde reeks. U gebruikt deze om het aantal elementen te bepalen dat zich momenteel in de gecontroleerde volgorde bevindt. Zie vector::empty (STL/CLR)()als u alleen wilt weten of de reeks een niet-nulgrootte heeft.

Voorbeeld

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

Het type ondertekende afstand tussen twee elementen.

Syntaxis

typedef int size_type;

Opmerkingen

Het type beschrijft een niet-negatief aantal elementen.

Voorbeeld

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

Hiermee wordt de inhoud van twee containers gewisseld.

Syntaxis

void swap(vector<Value>% right);

Parameters

Container waarmee inhoud moet worden gewisseld.

Opmerkingen

De lidfunctie wisselt de gecontroleerde reeksen tussen *this en rechter. Dit gebeurt in constante tijd en genereert geen uitzonderingen. U gebruikt deze functie als een snelle manier om de inhoud van twee containers uit te wisselen.

Voorbeeld

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

Hiermee kopieert u de gecontroleerde reeks naar een nieuwe matrix.

Syntaxis

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

Opmerkingen

De lidfunctie retourneert een matrix die de gecontroleerde reeks bevat. U gebruikt deze om een kopie van de gecontroleerde reeks in matrixvorm te verkrijgen.

Voorbeeld

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

Het type element.

Syntaxis

typedef Value value_type;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Waarde.

Voorbeeld

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

Maakt een containerobject.

Syntaxis

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

Parameters

aantal
Aantal elementen dat moet worden ingevoegd.

eerste
Begin van het bereik dat moet worden ingevoegd.

laatste
Einde van het bereik dat moet worden ingevoegd.

Object of bereik dat moet worden ingevoegd.

val-
De waarde van het element dat moet worden ingevoegd.

Opmerkingen

De constructor:

vector();

initialiseert de gecontroleerde reeks zonder elementen. U gebruikt deze om een lege initiële gecontroleerde reeks op te geven.

De constructor:

vector(vector<Value>% right);

initialiseert de gecontroleerde reeks met de reeks [right.begin(), right.end()). U gebruikt deze om een eerste gecontroleerde reeks op te geven die een kopie is van de reeks die wordt beheerd door het vectorobject rechts.

De constructor:

vector(vector<Value>^ right);

initialiseert de gecontroleerde reeks met de reeks [right->begin(), right->end()). U gebruikt deze om een initiële gecontroleerde reeks op te geven die een kopie is van de reeks die wordt beheerd door het vectorobject waarvan de ingang rechtsis.

De constructor:

explicit vector(size_type count);

initialiseert de gecontroleerde reeks met aantal elementen elk met waarde value_type(). U gebruikt deze om de container te vullen met elementen die allemaal de standaardwaarde hebben.

De constructor:

vector(size_type count, value_type val);

initialiseert de gecontroleerde reeks met aantal elementen elk met waarde val. U gebruikt deze om de container te vullen met elementen die allemaal dezelfde waarde hebben.

De constructor:

template<typename InIt>

vector(InIt first, InIt last);

initialiseert de gecontroleerde reeks met de reeks [first, last). U gebruikt deze om de gecontroleerde reeks een kopie van een andere reeks te maken.

De constructor:

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

initialiseert de gecontroleerde reeks met de volgorde die is aangewezen door de enumerator rechter. U gebruikt deze om de gecontroleerde reeks een kopie te maken van een andere reeks die wordt beschreven door een enumerator.

Voorbeeld

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

Vector is niet gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert !(left == right). U gebruikt deze om te testen of linker niet hetzelfde is als rechter wanneer de twee vectoren per element worden vergeleken.

Voorbeeld

// 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<` (vector) (STL/CLR)

Vector kleiner dan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert waar indien, voor de laagste positie i waarvoor !(right[i] < left[i]), ook waar is dat left[i] < right[i]. Anders retourneert het left->size() < right->size() U gebruikt deze om te testen of linker vóór rechter worden geordend wanneer de twee vectoren per element worden vergeleken.

Voorbeeld

// 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<=` (vector) (STL/CLR)

Vector kleiner dan of gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert !(right < left). U gebruikt deze om te testen of linker niet is gerangschikt na rechter wanneer de twee vectoren worden vergeleken met elementen.

Voorbeeld

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

Vector is gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert alleen waar als de reeksen die worden beheerd door linker- en rechter dezelfde lengte hebben en voor elke positie ileft[i] ==right[i]. U gebruikt deze om te testen of links hetzelfde is als rechter wanneer de twee vectoren per element worden vergeleken.

Voorbeeld

// 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>` (vector) (STL/CLR)

Vector groter dan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert right<left. U gebruikt deze om te testen of links na rechter wanneer de twee vectoren per element worden vergeleken.

Voorbeeld

// 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>=` (vector) (STL/CLR)

Vector groter dan of gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert !(left < right). U gebruikt deze om te testen of links niet is gerangschikt voordat rechter wanneer de twee vectoren worden vergeleken met elementen.

Voorbeeld

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

Delen via

vector (STL/CLR)

Syntaxis

Parameters

Eisen

Verklaringen

Interfaces

Opmerkingen

Leden

vector::assign (STL/CLR)

Syntaxis

Parameters

Opmerkingen

Voorbeeld

vector::at (STL/CLR)

Syntaxis

Parameters

Opmerkingen

Voorbeeld

vector::back (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::back_item (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::begin (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::capacity (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::clear (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::const_iterator (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::const_reference (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::const_reverse_iterator (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::d ifference_type (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::empty (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::end (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::gum (STL/CLR)

Syntaxis

Parameters

Opmerkingen

Voorbeeld

vector::front (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::front_item (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

vector::generic_container (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld