vector (STL/CLR)
Klasa szablonu opisuje obiekt, który kontroluje różną długość sekwencji elementów, które mają dostęp losowy. Kontener vector służy do zarządzania sekwencją elementów jako ciągłego bloku magazynu. Blok jest implementowany jako tablica, która rośnie na żądanie.
W poniższym opisie wartość jest taka sama jak Wartość, GValue chyba że ten ostatni jest typem ref, w takim przypadku jest to Value^.
Składnia
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>
{ ..... };
Parametry
Wartość
Typ elementu w kontrolowanej sekwencji.
Wymagania
Nagłówek:<cliext/vector>
Przestrzeń nazw: cliext
Deklaracje
| Definicja typu | opis |
|---|---|
| vector::const_iterator (STL/CLR) | Typ iteratora stałego dla kontrolowanej sekwencji. |
| vector::const_reference (STL/CLR) | Typ stałego odwołania do elementu. |
| vector::const_reverse_iterator (STL/CLR) | Typ iteratora stałej odwrotnej dla kontrolowanej sekwencji. |
| vector::difference_type (STL/CLR) | Typ odległości ze znakiem między dwoma elementami. |
| vector::generic_container (STL/CLR) | Typ interfejsu ogólnego dla kontenera. |
| vector::generic_iterator (STL/CLR) | Typ iteratora dla interfejsu ogólnego dla kontenera. |
| vector::generic_reverse_iterator (STL/CLR) | Typ iteratora odwrotnego dla interfejsu ogólnego dla kontenera. |
| vector::generic_value (STL/CLR) | Typ elementu dla interfejsu ogólnego kontenera. |
| vector::iterator (STL/CLR) | Typ iteratora dla kontrolowanej sekwencji. |
| vector::reference (STL/CLR) | Typ odwołania do elementu. |
| vector::reverse_iterator (STL/CLR) | Typ iteratora odwrotnego dla kontrolowanej sekwencji. |
| vector::size_type (STL/CLR) | Typ odległości ze znakiem między dwoma elementami. |
| vector::value_type (STL/CLR) | Typ elementu. |
| Funkcja elementów członkowskich | opis |
|---|---|
| vector::assign (STL/CLR) | Zastępuje wszystkie elementy. |
| vector::at (STL/CLR) | Uzyskuje dostęp do elementu na określonej pozycji. |
| vector::back (STL/CLR) | Uzyskuje dostęp do ostatniego elementu. |
| vector::begin (STL/CLR) | Określa początek kontrolowanej sekwencji. |
| vector::capacity (STL/CLR) | Raportuje rozmiar przydzielonego magazynu dla kontenera. |
| vector::clear (STL/CLR) | Usuwa wszystkie elementy. |
| vector::empty (STL/CLR) | Sprawdza, czy nie ma żadnych elementów. |
| vector::end (STL/CLR) | Określa koniec kontrolowanej sekwencji. |
| vector::erase (STL/CLR) | Usuwa elementy z określonych pozycji. |
| vector::front (STL/CLR) | Uzyskuje dostęp do pierwszego elementu. |
| vector::insert (STL/CLR) | Dodaje elementy w określonej pozycji. |
| vector::pop_back (STL/CLR) | Usuwa ostatni element. |
| vector::push_back (STL/CLR) | Dodaje nowy ostatni element. |
| vector::rbegin (STL/CLR) | Wyznacza początek odwróconej kontrolowanej sekwencji. |
| vector::rend (STL/CLR) | Wyznacza koniec odwróconej kontrolowanej sekwencji. |
| vector::reserve (STL/CLR) | Zapewnia minimalną pojemność wzrostu dla kontenera. |
| vector::resize (STL/CLR) | Zmienia liczbę elementów. |
| vector::size (STL/CLR) | Liczy liczbę elementów. |
| vector::swap (STL/CLR) | Zamienia zawartości dwóch kontenerów. |
| vector::to_array (STL/CLR) | Kopiuje kontrolowaną sekwencję do nowej tablicy. |
| vector::vector (STL/CLR) | Konstruuje obiekt kontenera. |
| Właściwości | opis |
|---|---|
| vector::back_item (STL/CLR) | Uzyskuje dostęp do ostatniego elementu. |
| vector::front_item (STL/CLR) | Uzyskuje dostęp do pierwszego elementu. |
| Operator | opis |
|---|---|
| vector::operator= (STL/CLR) | Zastępuje kontrolowaną sekwencję. |
| vector::operator(STL/CLR) | Uzyskuje dostęp do elementu na określonej pozycji. |
| operator!= (vector) (STL/CLR) | Określa, czy vector obiekt nie jest równy innemu vector obiektowi. |
| operator< (vector) (STL/CLR) | Określa, czy vector obiekt jest mniejszy niż inny vector obiekt. |
| operator<= (vector) (STL/CLR) | Określa, czy vector obiekt jest mniejszy lub równy innemu vector obiektowi. |
| operator== (vector) (STL/CLR) | Określa, czy vector obiekt jest równy innemu vector obiektowi. |
| operator> (vector) (STL/CLR) | Określa, czy vector obiekt jest większy niż inny vector obiekt. |
| operator>= (vector) (STL/CLR) | Określa, czy vector obiekt jest większy lub równy innemu vector obiektowi. |
Interfejsy
| Interfejs | opis |
|---|---|
| ICloneable | Duplikuj obiekt. |
| IEnumerable | Sekwencja elementów. |
| ICollection | Zachowaj grupę elementów. |
| IEnumerable<T> | Sekwencjonowanie przez wpisane elementy. |
| ICollection<T> | Zachowaj grupę wpisanych elementów. |
| IList<T> | Zachowaj uporządkowaną grupę typowanych elementów. |
| Wartość IVector<> | Obsługa ogólnego kontenera. |
Uwagi
Obiekt przydziela i zwalnia magazyn dla sekwencji, którą kontroluje za pośrednictwem przechowywanej tablicy elementów Value , które rosną na żądanie. Wzrost występuje w taki sposób, że koszt dołączania nowego elementu jest amortyzowany stały czas. Innymi słowy, koszt dodawania elementów na końcu nie zwiększa się średnio, ponieważ długość kontrolowanej sekwencji staje się większa. W związku z tym wektor jest dobrym kandydatem dla bazowego kontenera dla stosu klas szablonu (STL/CLR).
Obiekt vector obsługuje iteratory z dostępem losowym, co oznacza, że można odwoływać się do elementu bezpośrednio ze względu na jego położenie liczbowe, licząc od zera dla pierwszego (frontu) elementu, do size() - 1 ostatniego (tylnego) elementu. Oznacza to również, że wektor jest dobrym kandydatem dla kontenera bazowego dla klasy szablonu priority_queue (STL/CLR).
Iterator wektorów przechowuje uchwyt do skojarzonego obiektu wektora wraz z stronniczość elementu, który wyznacza. Iteratory można używać tylko ze skojarzonymi obiektami kontenera. Stronniczość elementu wektorowego jest taka sama jak jego pozycja.
Wstawianie lub wymazywanie elementów może zmienić wartość elementu przechowywaną na danej pozycji, więc wartość wyznaczona przez iterator może również ulec zmianie. (Kontener może wymagać skopiowania elementów w górę lub w dół, aby utworzyć otwór przed wstawianiem lub wypełnieniem otworu po wymazaniu). Niemniej jednak iterator wektorowy pozostaje prawidłowy tak długo, jak jego stronniczość znajduje się w zakresie [0, size()]. Ponadto prawidłowy iterator pozostaje wyłuskiwalny — można go użyć do uzyskania dostępu do lub zmiany wartości elementu, którą wyznaczy — tak długo, jak jego stronniczość nie jest równa size().
Wymazywanie lub usuwanie elementu wywołuje destruktor dla jego przechowywanej wartości. Zniszczenie kontenera spowoduje usunięcie wszystkich elementów. W związku z tym kontener, którego typ elementu jest klasą ref, gwarantuje, że żadne elementy nie przeżyją kontenera. Należy jednak pamiętać, że kontener uchwytów nie niszczy jego elementów.
Członkowie
vector::assign (STL/CLR)
Zastępuje wszystkie elementy.
Składnia
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);
Parametry
count
Liczba elementów do wstawienia.
Pierwszym
Początek zakresu do wstawienia.
Ostatnio
Koniec zakresu do wstawienia.
Prawo
Wyliczenie do wstawienia.
Val
Wartość elementu do wstawienia.
Uwagi
Pierwsza funkcja składowa zastępuje kontrolowaną sekwencję powtórzeniem elementów zliczanych wartości. Służy do wypełniania kontenera elementami o tej samej wartości.
Jeśli InIt jest typem całkowitym, druga funkcja składowa zachowuje się tak samo jak assign((size_type)first, (value_type)last). W przeciwnym razie zastępuje kontrolowaną sekwencję sekwencją [first, last). Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji.
Trzecia funkcja składowa zastępuje kontrolowaną sekwencję sekwencją wyznaczoną przez prawo modułu wyliczającego. Służy do tworzenia kontrolowanej sekwencji kopii sekwencji opisanej przez moduł wyliczający.
Przykład
// 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)
Uzyskuje dostęp do elementu na określonej pozycji.
Składnia
reference at(size_type pos);
Parametry
Poz
Pozycja elementu w celu uzyskania dostępu.
Uwagi
Funkcja składowa zwraca odwołanie do elementu kontrolowanej sekwencji w punktach pos położenia. Służy do odczytywania lub pisania elementu, którego pozycja jest wiadoma.
Przykład
// 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)
Uzyskuje dostęp do ostatniego elementu.
Składnia
reference back();
Uwagi
Funkcja składowa zwraca odwołanie do ostatniego elementu kontrolowanej sekwencji, który musi być niepusty. Służy do uzyskiwania dostępu do ostatniego elementu, gdy wiadomo, że istnieje.
Przykład
// 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)
Uzyskuje dostęp do ostatniego elementu.
Składnia
property value_type back_item;
Uwagi
Właściwość uzyskuje dostęp do ostatniego elementu kontrolowanej sekwencji, który musi być niepusty. Służy do odczytywania lub zapisywania ostatniego elementu, gdy wiadomo, że istnieje.
Przykład
// 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)
Określa początek kontrolowanej sekwencji.
Składnia
iterator begin();
Uwagi
Funkcja składowa zwraca iterator dostępu losowego, który wyznacza pierwszy element kontrolowanej sekwencji lub tuż poza końcem pustej sekwencji. Służy do uzyskania iteratora, który wyznacza current początek kontrolowanej sekwencji, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.
Przykład
// 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)
Raportuje rozmiar przydzielonego magazynu dla kontenera.
Składnia
size_type capacity();
Uwagi
Funkcja składowa zwraca magazyn, który jest obecnie przydzielony do przechowywania kontrolowanej sekwencji— wartość co najmniej tak duża, jak vector::size (STL/CLR).() Służy do określania, ile kontener może rosnąć, zanim będzie musiał ponownie przydzielić magazyn dla kontrolowanej sekwencji.
Przykład
// 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)
Usuwa wszystkie elementy.
Składnia
void clear();
Uwagi
Funkcja składowa skutecznie wywołuje vector::erase (STL/CLR)vector::begin (STL/CLR)(),(vector::end (STL/CLR).()) Służy do zapewnienia, że kontrolowana sekwencja jest pusta.
Przykład
// 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)
Typ iteratora stałego dla kontrolowanej sekwencji.
Składnia
typedef T2 const_iterator;
Uwagi
Typ opisuje obiekt nieokreślonego typu T2 , który może służyć jako stały iterator dostępu losowego dla kontrolowanej sekwencji.
Przykład
// 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)
Typ stałego odwołania do elementu.
Składnia
typedef value_type% const_reference;
Uwagi
Typ opisuje stałe odwołanie do elementu.
Przykład
// 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)
Typ iteratora stałej odwrotnej dla kontrolowanej sekwencji.
Składnia
typedef T4 const_reverse_iterator;
Uwagi
Typ opisuje obiekt nieokreślonego typu T4 , który może służyć jako stały iterator odwrotny dla kontrolowanej sekwencji.
Przykład
// 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)
Typy podpisanej odległości między dwoma elementami.
Składnia
typedef int difference_type;
Uwagi
Typ opisuje liczbę podpisanych elementów.
Przykład
// 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)
Sprawdza, czy nie ma żadnych elementów.
Składnia
bool empty();
Uwagi
Funkcja składowa zwraca wartość true dla pustej kontrolowanej sekwencji. Jest ona równoważna vector::size (STL/CLR)() == 0. Służy do testowania, czy wektor jest pusty.
Przykład
// 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)
Określa koniec kontrolowanej sekwencji.
Składnia
iterator end();
Uwagi
Funkcja składowa zwraca iterator dostępu losowego, który wskazuje tuż poza końcem kontrolowanej sekwencji. Służy do uzyskania iteratora, który wyznacza current koniec kontrolowanej sekwencji, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.
Przykład
// 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)
Usuwa elementy z określonych pozycji.
Składnia
iterator erase(iterator where);
iterator erase(iterator first, iterator last);
Parametry
Pierwszym
Początek zakresu do wymazywania.
Ostatnio
Koniec zakresu do wymazywania.
Gdzie
Element do wymazywania.
Uwagi
Pierwsza funkcja składowa usuwa element kontrolowanej sekwencji wskazywanej przez miejsce. Służy do usuwania pojedynczego elementu.
Druga funkcja składowa usuwa elementy kontrolowanej sekwencji w zakresie [first, last). Służy do usuwania zera lub większej liczby ciągłych elementów.
Obie funkcje składowe zwracają iterator, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub vector::end (STL/CLR),() jeśli taki element nie istnieje.
Podczas wymazywania elementów liczba kopii elementów jest liniowa w liczbie elementów między końcem wymazywania a bliższym końcem sekwencji. (W przypadku wymazywania jednego lub większej liczby elementów na końcu sekwencji nie ma kopii elementów).
Przykład
// 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)
Uzyskuje dostęp do pierwszego elementu.
Składnia
reference front();
Uwagi
Funkcja składowa zwraca odwołanie do pierwszego elementu kontrolowanej sekwencji, który musi być niepusty. Służy do odczytywania lub zapisywania pierwszego elementu, gdy wiadomo, że istnieje.
Przykład
// 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)
Uzyskuje dostęp do pierwszego elementu.
Składnia
property value_type front_item;
Uwagi
Właściwość uzyskuje dostęp do pierwszego elementu kontrolowanej sekwencji, który musi być niepusty. Służy do odczytywania lub zapisywania pierwszego elementu, gdy wiadomo, że istnieje.
Przykład
// 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)
Typ interfejsu ogólnego dla kontenera.
Składnia
typedef Microsoft::VisualC::StlClr::
IVector<generic_value>
generic_container;
Uwagi
Typ opisuje ogólny interfejs dla tej klasy kontenera szablonu.
Przykład
// 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)
Typ iteratora do użycia z interfejsem ogólnym kontenera.
Składnia
typedef Microsoft::VisualC::StlClr::Generic::
ContainerRandomAccessIterator<generic_value>
generic_iterator;
Uwagi
Typ opisuje iterator ogólny, który może być używany z interfejsem ogólnym dla tej klasy kontenera szablonu.
Przykład
// 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)
Typ iteratora odwrotnego do użycia z interfejsem ogólnym kontenera.
Składnia
typedef Microsoft::VisualC::StlClr::Generic::
ReverseRandomAccessIterator<generic_value> generic_reverse_iterator;
Uwagi
Typ opisuje ogólny iterator odwrotny, który może być używany z interfejsem ogólnym dla tej klasy kontenera szablonu.
Przykład
// 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)
Typ elementu do użycia z interfejsem ogólnym kontenera.
Składnia
typedef GValue generic_value;
Uwagi
Typ opisuje obiekt typu GValue , który opisuje przechowywaną wartość elementu do użycia z interfejsem ogólnym dla tej klasy kontenera szablonu.
Przykład
// 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)
Dodaje elementy w określonej pozycji.
Składnia
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);
Parametry
count
Liczba elementów do wstawienia.
Pierwszym
Początek zakresu do wstawienia.
Ostatnio
Koniec zakresu do wstawienia.
Prawo
Wyliczenie do wstawienia.
Val
Wartość elementu do wstawienia.
Gdzie
Gdzie w kontenerze do wstawienia przed.
Uwagi
Każda z funkcji składowych wstawia element przed elementem wskazującym , gdzie w kontrolowanej sekwencji, sekwencja określona przez pozostałe operandy.
Pierwsza funkcja składowa wstawia element z wartością val i zwraca iterator, który wyznacza nowo wstawiony element. Służy do wstawiania pojedynczego elementu przed miejscem wyznaczonym przez iterator.
Druga funkcja składowa wstawia powtórzenie elementów zliczania wartości. Służy do wstawiania zera lub większej liczby ciągłych elementów, które są wszystkimi kopiami tej samej wartości.
Jeśli InIt jest typem całkowitym, trzecia funkcja składowa zachowuje się tak samo jak insert(where, (size_type)first, (value_type)last). W przeciwnym razie wstawia sekwencję [first, last). Służy do wstawiania zera lub większej liczby ciągłych elementów skopiowanych z innej sekwencji.
Czwarta funkcja składowa wstawia sekwencję wyznaczoną po prawej stronie. Służy do wstawiania sekwencji opisanej przez moduł wyliczający.
Podczas wstawiania pojedynczego elementu liczba kopii elementów jest liniowa w liczbie elementów między punktem wstawiania a bliższym końcem sekwencji. (Podczas wstawiania co najmniej jednego elementu na końcu sekwencji nie ma kopii elementów). Jeśli InIt jest iteratorem wejściowym, trzecia funkcja składowa skutecznie wykonuje pojedynczą wstawienie dla każdego elementu w sekwencji. W przeciwnym razie podczas wstawiania N elementów liczba kopii elementów jest liniowa N i liczba elementów między punktem wstawiania a bliższym końcem sekwencji.
Przykład
// 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)
Typ iteratora dla kontrolowanej sekwencji.
Składnia
typedef T1 iterator;
Uwagi
Typ opisuje obiekt nieokreślonego typu T1 , który może służyć jako iterator dostępu losowego dla kontrolowanej sekwencji.
Przykład
// 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)
Zastępuje kontrolowaną sekwencję.
Składnia
vector<Value>% operator=(vector<Value>% right);
Parametry
Prawo
Kontener do skopiowania.
Uwagi
Operator elementu członkowskiego kopiuje prawo do obiektu, a następnie zwraca wartość *this. Służy do zastępowania kontrolowanej sekwencji kopią kontrolowanej sekwencji po prawej stronie.
Przykład
// 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)
Uzyskuje dostęp do elementu na określonej pozycji.
Składnia
reference operator[](size_type pos);
Parametry
Poz
Pozycja elementu w celu uzyskania dostępu.
Uwagi
Operator elementu członkowskiego zwraca odwołanie do elementu w pozycji pos. Służy do uzyskiwania dostępu do elementu, którego położenie znasz.
Przykład
// 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)
Usuwa ostatni element.
Składnia
void pop_back();
Uwagi
Funkcja składowa usuwa ostatni element kontrolowanej sekwencji, który musi być niepusty. Służy do skrócenia wektora przez jeden element z tyłu.
Przykład
// 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)
Dodaje nowy ostatni element.
Składnia
void push_back(value_type val);
Uwagi
Funkcja składowa wstawia element z wartością val na końcu kontrolowanej sekwencji. Służy do dołączania innego elementu do wektora.
Przykład
// 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)
Wyznacza początek odwróconej kontrolowanej sekwencji.
Składnia
reverse_iterator rbegin();
Uwagi
Funkcja składowa zwraca iterator odwrotny, który wyznacza ostatni element kontrolowanej sekwencji lub tuż poza początkiem pustej sekwencji. W związku z tym wyznacza beginning sekwencję odwrotną. Służy do uzyskania iteratora, który wyznacza current początek kontrolowanej sekwencji widocznej w odwrotnej kolejności, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.
Przykład
// 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)
Typ odwołania do elementu.
Składnia
typedef value_type% reference;
Uwagi
Typ opisuje odwołanie do elementu.
Przykład
// 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)
Wyznacza koniec odwróconej kontrolowanej sekwencji.
Składnia
reverse_iterator rend();
Uwagi
Funkcja składowa zwraca iterator odwrotny, który wskazuje tuż poza początkiem kontrolowanej sekwencji. W związku z tym wyznacza end sekwencję odwrotną. Służy do uzyskania iteratora, który wyznacza current koniec kontrolowanej sekwencji widocznej w odwrotnej kolejności, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.
Przykład
// 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)
Zapewnia minimalną pojemność wzrostu dla kontenera.
Składnia
void reserve(size_type count);
Parametry
count
Nowa minimalna pojemność kontenera.
Uwagi
Funkcja składowa zapewnia, że capacity() w związku z tym zwraca co najmniej liczbę. Służy do zapewnienia, że kontener nie musi ponownie przydzielić magazynu dla kontrolowanej sekwencji, dopóki nie zostanie przeniesiony do określonego rozmiaru.
Przykład
// 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)
Zmienia liczbę elementów.
Składnia
void resize(size_type new_size);
void resize(size_type new_size, value_type val);
Parametry
new_size
Nowy rozmiar kontrolowanej sekwencji.
Val
Wartość elementu dopełniania.
Uwagi
Funkcje składowe zapewniają, że funkcja vector::size (STL/CLR)() zwraca new_size. Jeśli musi ona wydłużyć kontrolowaną sekwencję, pierwsza funkcja składowa dołącza elementy z wartością , podczas gdy druga funkcja składowa dołącza elementy z wartością value_type()val. Aby skrócić kontrolowaną sekwencję, oba funkcje składowe skutecznie usuwają ostatni czas wektora elementu::size (STL/CLR() -new_size). Służy do zapewnienia, że kontrolowana sekwencja ma rozmiar new_size, przycinając lub dopełniając bieżącą kontrolowaną sekwencję.
Przykład
// 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)
Typ iteratora odwrotnego dla kontrolowanej sekwencji.
Składnia
typedef T3 reverse_iterator;
Uwagi
Typ opisuje obiekt nieokreślonego typu T3 , który może służyć jako iterator odwrotny dla kontrolowanej sekwencji.
Przykład
// 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)
Liczy liczbę elementów.
Składnia
size_type size();
Uwagi
Funkcja składowa zwraca długość kontrolowanej sekwencji. Służy do określania liczby elementów aktualnie w kontrolowanej sekwencji. Jeśli chodzi o to, czy sekwencja ma rozmiar niezerowy, zobacz vector::empty (STL/CLR)().
Przykład
// 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)
Typ odległości ze znakiem między dwoma elementami.
Składnia
typedef int size_type;
Uwagi
Typ opisuje nieujemną liczbę elementów.
Przykład
// 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)
Zamienia zawartości dwóch kontenerów.
Składnia
void swap(vector<Value>% right);
Parametry
Prawo
Kontener do zamiany zawartości na.
Uwagi
Funkcja składowa zamienia kontrolowane sekwencje między *this i po prawej stronie. Robi to w stałym czasie i nie zgłasza żadnych wyjątków. Służy ona jako szybki sposób wymiany zawartości dwóch kontenerów.
Przykład
// 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)
Kopiuje kontrolowaną sekwencję do nowej tablicy.
Składnia
cli::array<Value>^ to_array();
Uwagi
Funkcja składowa zwraca tablicę zawierającą kontrolowaną sekwencję. Służy do uzyskiwania kopii kontrolowanej sekwencji w postaci tablicy.
Przykład
// 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)
Typ elementu.
Składnia
typedef Value value_type;
Uwagi
Typ jest synonimem wartości parametru szablonu.
Przykład
// 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)
Konstruuje obiekt kontenera.
Składnia
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);
Parametry
count
Liczba elementów do wstawienia.
Pierwszym
Początek zakresu do wstawienia.
Ostatnio
Koniec zakresu do wstawienia.
Prawo
Obiekt lub zakres do wstawienia.
Val
Wartość elementu do wstawienia.
Uwagi
Konstruktor:
vector();
inicjuje kontrolowaną sekwencję bez elementów. Służy do określania pustej początkowej kontrolowanej sekwencji.
Konstruktor:
vector(vector<Value>% right);
inicjuje kontrolowaną sekwencję za pomocą sekwencji [right.begin(), right.end()). Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez obiekt wektora po prawej stronie.
Konstruktor:
vector(vector<Value>^ right);
inicjuje kontrolowaną sekwencję za pomocą sekwencji [right->begin(), right->end()). Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez obiekt wektora, którego uchwyt jest właściwy.
Konstruktor:
explicit vector(size_type count);
inicjuje kontrolowaną sekwencję z elementami zliczanymi z wartością value_type(). Służy do wypełniania kontenera elementami, które mają wartość domyślną.
Konstruktor:
vector(size_type count, value_type val);
inicjuje kontrolowaną sekwencję z elementami zliczanymi z każdą wartością. Służy do wypełniania kontenera elementami o tej samej wartości.
Konstruktor:
template<typename InIt>
vector(InIt first, InIt last);
inicjuje kontrolowaną sekwencję za pomocą sekwencji [first, last). Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji.
Konstruktor:
vector(System::Collections::Generic::IEnumerable<Value>^ right);
inicjuje kontrolowaną sekwencję z sekwencją wyznaczoną przez prawo modułu wyliczającego. Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji opisanej przez moduł wyliczający.
Przykład
// 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)
Wektor nie jest równy porównaniem.
Składnia
template<typename Value>
bool operator!=(vector<Value>% left,
vector<Value>% right);
Parametry
Lewej
Pozostaw kontener do porównania.
Prawo
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca !(left == right)wartość . Służy do testowania, czy lewo nie jest uporządkowane tak samo jak w prawo , gdy dwa wektory są porównywane element według elementu.
Przykład
// 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< (wektor) (STL/CLR)
Wektor mniejszy niż porównanie.
Składnia
template<typename Value>
bool operator<(vector<Value>% left,
vector<Value>% right);
Parametry
Lewej
Pozostaw kontener do porównania.
Prawo
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca wartość true, jeśli dla najniższej pozycji i , dla której !(right[i] < left[i]) jest również prawdziwe, że left[i] < right[i]. W przeciwnym razie zwraca left->size() < right->size() wartość Użyto go do sprawdzenia, czy lewa jest uporządkowana przed prawej, gdy dwa wektory są porównywane element według elementu.
Przykład
// 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<= (wektor) (STL/CLR)
Wektor mniejszy niż lub równy porównanie.
Składnia
template<typename Value>
bool operator<=(vector<Value>% left,
vector<Value>% right);
Parametry
Lewej
Pozostaw kontener do porównania.
Prawo
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca !(right < left)wartość . Służy do testowania, czy lewo nie jest uporządkowane po prawej stronie , gdy dwa wektory są porównywane element według elementu.
Przykład
// 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)
Wektor równe porównanie.
Składnia
template<typename Value>
bool operator==(vector<Value>% left,
vector<Value>% right);
Parametry
Lewej
Pozostaw kontener do porównania.
Prawo
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca wartość true tylko wtedy, gdy sekwencje kontrolowane przez lewą i prawą mają taką samą długość, a dla każdej pozycji i, left[i] ==right[i]. Służy do testowania, czy lewo jest uporządkowane tak samo jak w prawo , gdy dwa wektory są porównywane element według elementu.
Przykład
// 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> (wektor) (STL/CLR)
Wektor większy niż porównanie.
Składnia
template<typename Value>
bool operator>(vector<Value>% left,
vector<Value>% right);
Parametry
Lewej
Pozostaw kontener do porównania.
Prawo
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca right<leftwartość . Służy do testowania, czy lewo jest uporządkowane po prawej stronie , gdy dwa wektory są porównywane element według elementu.
Przykład
// 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>= (wektor) (STL/CLR)
Wektor większy niż lub równy porównanie.
Składnia
template<typename Value>
bool operator>=(vector<Value>% left,
vector<Value>% right);
Parametry
Lewej
Pozostaw kontener do porównania.
Prawo
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca !(left < right)wartość . Służy do testowania, czy lewo nie jest uporządkowane przed prawej, gdy dwa wektory są porównywane element według elementu.
Przykład
// 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
Opinia
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź: https://aka.ms/ContentUserFeedback.
Prześlij i wyświetl opinię dla