vector (STL/CLR)
La classe modello descrive un oggetto che controlla una sequenza di elementi di lunghezza variabile con accesso casuale. Il contenitore vector viene usato per gestire una sequenza di elementi come blocco contiguo di archiviazione. Il blocco viene implementato come matrice che aumenta su richiesta.
Nella descrizione seguente GValue , è uguale a Value a meno che quest'ultimo non sia un tipo ref, nel qual caso è Value^.
Sintassi
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>
{ ..... };
Parametri
valore
Tipo di un elemento nella sequenza controllata.
Requisiti
Intestazione:<cliext/vector>
Spazio dei nomi: cliext
Dichiarazioni
| Definizione del tipo | Descrizione |
|---|---|
| vector::const_iterator (STL/CLR) | Tipo di un iteratore costante per la sequenza controllata. |
| vector::const_reference (STL/CLR) | Tipo di un riferimento costante a un elemento. |
| vector::const_reverse_iterator (STL/CLR) | Tipo di un iteratore inverso costante per la sequenza controllata. |
| vector::difference_type (STL/CLR) | Tipo di una distanza Signed tra due elementi. |
| vector::generic_container (STL/CLR) | Tipo dell'interfaccia generica per il contenitore. |
| vector::generic_iterator (STL/CLR) | Tipo di iteratore per l'interfaccia generica per il contenitore. |
| vector::generic_reverse_iterator (STL/CLR) | Tipo di iteratore inverso per l'interfaccia generica per il contenitore. |
| vector::generic_value (STL/CLR) | Tipo di elemento per l'interfaccia generica per il contenitore. |
| vector::iterator (STL/CLR) | Tipo di un iteratore per la sequenza controllata. |
| vector::reference (STL/CLR) | Tipo di un riferimento a un elemento. |
| vector::reverse_iterator (STL/CLR) | Tipo di un iteratore inverso della sequenza controllata. |
| vector::size_type (STL/CLR) | Tipo di una distanza Signed tra due elementi. |
| vector::value_type (STL/CLR) | Tipo di un elemento. |
| Funzione membro | Descrizione |
|---|---|
| vector::assign (STL/CLR) | Sostituisce tutti gli elementi. |
| vector::at (STL/CLR) | Accede a un elemento in una posizione specificata. |
| vector::back (STL/CLR) | Accede all'ultimo elemento. |
| vector::begin (STL/CLR) | Indica l'inizio della sequenza controllata. |
| vector::capacity (STL/CLR) | Segnala le dimensioni dell'archiviazione allocata per il contenitore. |
| vector::clear (STL/CLR) | Rimuove tutti gli elementi. |
| vector::empty (STL/CLR) | Verifica se sono presenti o meno degli elementi. |
| vector::end (STL/CLR) | Designa la fine della sequenza controllata. |
| vector::erase (STL/CLR) | Rimuove gli elementi in corrispondenza delle posizioni specificate. |
| vector::front (STL/CLR) | Accede al primo elemento. |
| vector::insert (STL/CLR) | Aggiunge elementi in una posizione specificata. |
| vector::pop_back (STL/CLR) | Rimuove l'ultimo elemento. |
| vector::push_back (STL/CLR) | Aggiunge un nuovo ultimo elemento. |
| vector::rbegin (STL/CLR) | Indica l'inizio della sequenza controllata inversa. |
| vector::rend (STL/CLR) | Indica la fine della sequenza controllata inversa. |
| vector::reserve (STL/CLR) | Garantisce una capacità di crescita minima per il contenitore. |
| vector::resize (STL/CLR) | Modifica il numero di elementi. |
| vector::size (STL/CLR) | Conta il numero di elementi. |
| vector::swap (STL/CLR) | Scambia il contenuto di due contenitori. |
| vector::to_array (STL/CLR) | Copia la sequenza controllata in una nuova matrice. |
| vector::vector (STL/CLR) | Costruisce un oggetto contenitore. |
| Proprietà | Descrizione |
|---|---|
| vector::back_item (STL/CLR) | Accede all'ultimo elemento. |
| vector::front_item (STL/CLR) | Accede al primo elemento. |
| Operatore | Descrizione |
|---|---|
| vector::operator= (STL/CLR) | Sostituisce la sequenza controllata. |
| vector::operator(STL/CLR) | Accede a un elemento in una posizione specificata. |
| operator!= (vector) (STL/CLR) | Determina se un vector oggetto non è uguale a un altro vector oggetto. |
| operator< (vector) (STL/CLR) | Determina se un vector oggetto è minore di un altro vector oggetto. |
| operator<= (vector) (STL/CLR) | Determina se un vector oggetto è minore o uguale a un altro vector oggetto. |
| operator== (vector) (STL/CLR) | Determina se un vector oggetto è uguale a un altro vector oggetto. |
| operator> (vector) (STL/CLR) | Determina se un vector oggetto è maggiore di un altro vector oggetto. |
| operator>= (vector) (STL/CLR) | Determina se un vector oggetto è maggiore o uguale a un altro vector oggetto. |
Interfacce
| Interfaccia | Descrizione |
|---|---|
| ICloneable | Duplicare un oggetto . |
| IEnumerable | Sequenzia tra elementi. |
| ICollection | Mantenere il gruppo di elementi. |
| IEnumerable<T> | Sequenzia tra elementi tipizzato. |
| ICollection<T> | Mantenere un gruppo di elementi tipizzato. |
| IList<T> | Mantenere un gruppo ordinato di elementi tipizzato. |
| Valore IVector<> | Gestire un contenitore generico. |
Osservazioni:
L'oggetto alloca e libera l'archiviazione per la sequenza che controlla tramite una matrice archiviata di elementi Value , che aumenta su richiesta. La crescita si verifica in modo che il costo di accodamento di un nuovo elemento sia un tempo costante ammortizzato. In altre parole, il costo dell'aggiunta di elementi alla fine non aumenta, in media, poiché la lunghezza della sequenza controllata diventa più grande. Pertanto, un vettore è un buon candidato per il contenitore sottostante per lo stack di classi modello (STL/CLR).
Un vector oggetto supporta iteratori ad accesso casuale, ovvero è possibile fare riferimento a un elemento direttamente in base alla relativa posizione numerica, contando da zero per il primo elemento (anteriore) a size() - 1 per l'ultimo elemento (indietro). Significa anche che un vettore è un buon candidato per il contenitore sottostante per la classe modello priority_queue (STL/CLR).
Un iteratore vettoriale archivia un handle all'oggetto vettore associato, insieme alla distorsione dell'elemento designato. È possibile usare gli iteratori solo con gli oggetti contenitore associati. La distorsione di un elemento vettore è la stessa della posizione.
L'inserimento o la cancellazione di elementi può modificare il valore dell'elemento archiviato in una determinata posizione, in modo che il valore designato da un iteratore possa anche cambiare. Il contenitore potrebbe dover copiare gli elementi verso l'alto o verso il basso per creare un foro prima di un inserimento o per riempire un foro dopo una cancellazione. Tuttavia, un iteratore vettoriale rimane valido fino a quando la distorsione si trova nell'intervallo [0, size()]. Inoltre, un iteratore valido rimane dereferenziabile - è possibile usarlo per accedere o modificare il valore dell'elemento designato - purché la distorsione non sia uguale a size().
Cancellare o rimuovere un elemento chiama il distruttore per il valore archiviato. L'eliminazione definitiva del contenitore cancella tutti gli elementi. Pertanto, un contenitore il cui tipo di elemento è una classe ref garantisce che nessun elemento scadeni il contenitore. Si noti, tuttavia, che un contenitore di handle non elimina definitivamente i relativi elementi.
Membri
vector::assign (STL/CLR)
Sostituisce tutti gli elementi.
Sintassi
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);
Parametri
count
Numero di elementi da inserire.
first
Inizio dell'intervallo da inserire.
last
Fine dell'intervallo da inserire.
right
Enumerazione da inserire.
val
Valore dell'elemento da inserire.
Osservazioni:
La prima funzione membro sostituisce la sequenza controllata con una ripetizione di elementi count di valore val. È possibile usarlo per riempire il contenitore con tutti gli elementi con lo stesso valore.
Se InIt è un tipo integer, la seconda funzione membro si comporta come assign((size_type)first, (value_type)last). In caso contrario, sostituisce la sequenza controllata con la sequenza [first, last). Viene usato per rendere la sequenza controllata una copia di un'altra sequenza.
La terza funzione membro sostituisce la sequenza controllata con la sequenza designata dal diritto dell'enumeratore. È possibile usarla per rendere la sequenza controllata una copia di una sequenza descritta da un enumeratore.
Esempio
// 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)
Accede a un elemento in una posizione specificata.
Sintassi
reference at(size_type pos);
Parametri
pos
Posizione dell'elemento a cui accedere.
Osservazioni:
La funzione membro restituisce un riferimento all'elemento della sequenza controllata in corrispondenza della posizione pos. È possibile usarlo per leggere o scrivere un elemento la cui posizione si conosce.
Esempio
// 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)
Accede all'ultimo elemento.
Sintassi
reference back();
Osservazioni:
La funzione membro restituisce un riferimento all'ultimo elemento della sequenza controllata, che deve essere non vuoto. È possibile usarlo per accedere all'ultimo elemento, quando si sa che esiste.
Esempio
// 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)
Accede all'ultimo elemento.
Sintassi
property value_type back_item;
Osservazioni:
La proprietà accede all'ultimo elemento della sequenza controllata, che deve essere non vuoto. È possibile usarlo per leggere o scrivere l'ultimo elemento, quando si sa che esiste.
Esempio
// 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)
Indica l'inizio della sequenza controllata.
Sintassi
iterator begin();
Osservazioni:
La funzione membro restituisce un iteratore ad accesso casuale che definisce il primo elemento della sequenza controllata o appena oltre la fine di una sequenza vuota. Viene usato per ottenere un iteratore che designa l'inizio current della sequenza controllata, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.
Esempio
// 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)
Segnala le dimensioni dell'archiviazione allocata per il contenitore.
Sintassi
size_type capacity();
Osservazioni:
La funzione membro restituisce lo spazio di archiviazione attualmente allocato per contenere la sequenza controllata, un valore almeno di grandi dimensioni come vector::size (STL/CLR).The member function returns the storage currently allocate to hold the controlled sequence, a value at least as vector::size (STL/CLR)(). È possibile usarlo per determinare quanto può crescere il contenitore prima di riallocare l'archiviazione per la sequenza controllata.
Esempio
// 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)
Rimuove tutti gli elementi.
Sintassi
void clear();
Osservazioni:
La funzione membro chiama in modo efficace vector::erase (STL/CLR)(vector::begin (STL/CLR)(),vector::end (STL/CLR).()) Viene usato per assicurarsi che la sequenza controllata sia vuota.
Esempio
// 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)
Tipo di un iteratore costante per la sequenza controllata.
Sintassi
typedef T2 const_iterator;
Osservazioni:
Il tipo descrive un oggetto di tipo T2 non specificato che può fungere da iteratore costante ad accesso casuale per la sequenza controllata.
Esempio
// 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)
Tipo di un riferimento costante a un elemento.
Sintassi
typedef value_type% const_reference;
Osservazioni:
Il tipo descrive un riferimento costante a un elemento.
Esempio
// 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)
Tipo di iteratore inverso costante per la sequenza controllata.
Sintassi
typedef T4 const_reverse_iterator;
Osservazioni:
Il tipo descrive un oggetto di tipo T4 non specificato che può fungere da iteratore inverso costante per la sequenza controllata.
Esempio
// 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)
Tipi di distanza con segno tra due elementi.
Sintassi
typedef int difference_type;
Osservazioni:
Il tipo descrive un conteggio degli elementi con segno.
Esempio
// 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)
Verifica se sono presenti o meno degli elementi.
Sintassi
bool empty();
Osservazioni:
La funzione membro restituisce true per una sequenza controllata vuota. Equivale a vector::size (STL/CLR).() == 0 Viene usato per verificare se il vettore è vuoto.
Esempio
// 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)
Designa la fine della sequenza controllata.
Sintassi
iterator end();
Osservazioni:
La funzione membro restituisce un iteratore ad accesso casuale che punta appena oltre la fine della sequenza controllata. È possibile usarlo per ottenere un iteratore che designa la current fine della sequenza controllata, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.
Esempio
// 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)
Rimuove gli elementi in corrispondenza delle posizioni specificate.
Sintassi
iterator erase(iterator where);
iterator erase(iterator first, iterator last);
Parametri
first
Inizio dell'intervallo da cancellare.
last
Fine dell'intervallo da cancellare.
where
Elemento da cancellare.
Osservazioni:
La prima funzione membro rimuove l'elemento della sequenza controllata a cui punta dove. Viene usato per rimuovere un singolo elemento.
La seconda funzione membro rimuove gli elementi della sequenza controllata nell'intervallo [first, last). È possibile usarlo per rimuovere zero o più elementi contigui.
Entrambe le funzioni membro restituiscono un iteratore che designa il primo elemento rimanente oltre qualsiasi elemento rimosso o vector::end (STL/CLR)() se tale elemento non esiste.
Quando si cancellano gli elementi, il numero di copie degli elementi è lineare nel numero di elementi tra la fine della cancellazione e la fine più vicina della sequenza. Quando si cancella uno o più elementi alla fine della sequenza, non viene eseguita alcuna copia di elementi.
Esempio
// 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)
Accede al primo elemento.
Sintassi
reference front();
Osservazioni:
La funzione membro restituisce un riferimento al primo elemento della sequenza controllata, che deve essere non vuoto. Lo si usa per leggere o scrivere il primo elemento, quando si sa che esiste.
Esempio
// 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)
Accede al primo elemento.
Sintassi
property value_type front_item;
Osservazioni:
La proprietà accede al primo elemento della sequenza controllata, che deve essere non vuoto. Lo si usa per leggere o scrivere il primo elemento, quando si sa che esiste.
Esempio
// 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)
Tipo dell'interfaccia generica per il contenitore.
Sintassi
typedef Microsoft::VisualC::StlClr::
IVector<generic_value>
generic_container;
Osservazioni:
Il tipo descrive l'interfaccia generica per questa classe contenitore modello.
Esempio
// 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)
Tipo di iteratore da usare con l'interfaccia generica per il contenitore.
Sintassi
typedef Microsoft::VisualC::StlClr::Generic::
ContainerRandomAccessIterator<generic_value>
generic_iterator;
Osservazioni:
Il tipo descrive un iteratore generico che può essere usato con l'interfaccia generica per questa classe contenitore modello.
Esempio
// 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)
Tipo di iteratore inverso da usare con l'interfaccia generica per il contenitore.
Sintassi
typedef Microsoft::VisualC::StlClr::Generic::
ReverseRandomAccessIterator<generic_value> generic_reverse_iterator;
Osservazioni:
Il tipo descrive un iteratore inverso generico che può essere usato con l'interfaccia generica per questa classe contenitore modello.
Esempio
// 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)
Tipo di un elemento da usare con l'interfaccia generica per il contenitore.
Sintassi
typedef GValue generic_value;
Osservazioni:
Il tipo descrive un oggetto di tipo GValue che descrive il valore dell'elemento archiviato da usare con l'interfaccia generica per questa classe contenitore modello.
Esempio
// 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)
Aggiunge elementi in una posizione specificata.
Sintassi
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);
Parametri
count
Numero di elementi da inserire.
first
Inizio dell'intervallo da inserire.
last
Fine dell'intervallo da inserire.
right
Enumerazione da inserire.
val
Valore dell'elemento da inserire.
where
Posizione nel contenitore da inserire prima.
Osservazioni:
Ognuna delle funzioni membro inserisce, prima dell'elemento a cui punta dove nella sequenza controllata, una sequenza specificata dagli operandi rimanenti.
La prima funzione membro inserisce un elemento con valore val e restituisce un iteratore che designa l'elemento appena inserito. Viene usato per inserire un singolo elemento prima di una posizione designata da un iteratore.
La seconda funzione membro inserisce una ripetizione di elementi count di valore val. Viene usato per inserire zero o più elementi contigui che sono tutte copie dello stesso valore.
Se InIt è di tipo Integer, la terza funzione membro si comporta come insert(where, (size_type)first, (value_type)last). In caso contrario, inserisce la sequenza [first, last). Viene usato per inserire zero o più elementi contigui copiati da un'altra sequenza.
La quarta funzione membro inserisce la sequenza designata dalla destra. Viene usato per inserire una sequenza descritta da un enumeratore.
Quando si inserisce un singolo elemento, il numero di copie degli elementi è lineare nel numero di elementi tra il punto di inserimento e la fine più vicina della sequenza. Quando si inseriscono uno o più elementi alla fine della sequenza, non vengono eseguite copie di elementi. Se InIt è un iteratore di input, la terza funzione membro esegue in modo efficace un singolo inserimento per ogni elemento nella sequenza. In caso contrario, quando si inseriscono N elementi, il numero di copie degli elementi è lineare in N più il numero di elementi tra il punto di inserimento e la fine più vicina della sequenza.
Esempio
// 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)
Tipo di un iteratore per la sequenza controllata.
Sintassi
typedef T1 iterator;
Osservazioni:
Il tipo descrive un oggetto di tipo T1 non specificato che può fungere da iteratore ad accesso casuale per la sequenza controllata.
Esempio
// 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)
Sostituisce la sequenza controllata.
Sintassi
vector<Value>% operator=(vector<Value>% right);
Parametri
right
Contenitore da copiare.
Osservazioni:
L'operatore membro copia direttamente nell'oggetto , quindi restituisce *this. Lo si usa per sostituire la sequenza controllata con una copia della sequenza controllata a destra.
Esempio
// 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)
Accede a un elemento in una posizione specificata.
Sintassi
reference operator[](size_type pos);
Parametri
pos
Posizione dell'elemento a cui accedere.
Osservazioni:
L'operatore membro restituisce un referene all'elemento in corrispondenza della posizione pos. È possibile usarlo per accedere a un elemento la cui posizione si conosce.
Esempio
// 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)
Rimuove l'ultimo elemento.
Sintassi
void pop_back();
Osservazioni:
La funzione membro rimuove l'ultimo elemento della sequenza controllata, che deve essere non vuoto. Lo si usa per abbreviare il vettore di un elemento nella parte posteriore.
Esempio
// 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)
Aggiunge un nuovo ultimo elemento.
Sintassi
void push_back(value_type val);
Osservazioni:
La funzione membro inserisce un elemento con valore val alla fine della sequenza controllata. Viene usato per accodare un altro elemento al vettore.
Esempio
// 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)
Indica l'inizio della sequenza controllata inversa.
Sintassi
reverse_iterator rbegin();
Osservazioni:
La funzione membro restituisce un iteratore inverso che definisce l'ultimo elemento della sequenza controllata o appena oltre l'inizio di una sequenza vuota. Di conseguenza, designa l'oggetto beginning della sequenza inversa. Viene usato per ottenere un iteratore che definisce l'inizio current della sequenza controllata visualizzata in ordine inverso, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.
Esempio
// 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)
Tipo di un riferimento a un elemento.
Sintassi
typedef value_type% reference;
Osservazioni:
Il tipo descrive un riferimento a un elemento.
Esempio
// 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)
Indica la fine della sequenza controllata inversa.
Sintassi
reverse_iterator rend();
Osservazioni:
La funzione membro restituisce un iteratore inverso che punta appena oltre l'inizio della sequenza controllata. Di conseguenza, designa l'oggetto end della sequenza inversa. Viene usato per ottenere un iteratore che designa la current fine della sequenza controllata visualizzata in ordine inverso, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.
Esempio
// 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)
Garantisce una capacità di crescita minima per il contenitore.
Sintassi
void reserve(size_type count);
Parametri
count
Nuova capacità minima del contenitore.
Osservazioni:
La funzione membro garantisce che capacity() quindi restituisca almeno il conteggio. Viene usata per assicurarsi che il contenitore non debba riallocare lo spazio di archiviazione per la sequenza controllata fino a quando non è cresciuto fino alla dimensione specificata.
Esempio
// 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)
Modifica il numero di elementi.
Sintassi
void resize(size_type new_size);
void resize(size_type new_size, value_type val);
Parametri
new_size
Nuove dimensioni della sequenza controllata.
val
Valore dell'elemento di riempimento.
Osservazioni:
Le funzioni membro assicurano che vector::size (STL/CLR)() restituisca quindi new_size. Se deve rendere più lunga la sequenza controllata, la prima funzione membro aggiunge elementi con valore value_type(), mentre la seconda funzione membro aggiunge elementi con value val. Per rendere più breve la sequenza controllata, entrambe le funzioni membro cancellano efficacemente l'ultimo elemento vector::size (STL/CLR).() -new_size Viene usato per assicurarsi che la sequenza controllata abbia dimensioni new_size, tagliando o riempimento la sequenza controllata corrente.
Esempio
// 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)
Tipo di un iteratore inverso della sequenza controllata.
Sintassi
typedef T3 reverse_iterator;
Osservazioni:
Il tipo descrive un oggetto di tipo non specificato T3 che può essere utilizzato come iteratore inverso per la sequenza controllata.
Esempio
// 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)
Conta il numero di elementi.
Sintassi
size_type size();
Osservazioni:
La funzione membro restituisce la lunghezza della sequenza controllata. Viene usato per determinare il numero di elementi attualmente presenti nella sequenza controllata. Se tutto ciò che interessa è se la sequenza ha dimensioni diverse da zero, vedere vector::empty (STL/CLR).If all you care about is if the sequence has nonzero size, see vector::empty (STL/CLR)().
Esempio
// 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)
Tipo di una distanza Signed tra due elementi.
Sintassi
typedef int size_type;
Osservazioni:
Il tipo descrive un numero di elementi non negativi.
Esempio
// 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)
Scambia il contenuto di due contenitori.
Sintassi
void swap(vector<Value>% right);
Parametri
right
Contenitore con cui scambiare il contenuto.
Osservazioni:
La funzione membro scambia le sequenze controllate tra *this e destra. Lo fa in tempo costante e non genera eccezioni. È possibile usarlo come modo rapido per scambiare il contenuto di due contenitori.
Esempio
// 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)
Copia la sequenza controllata in una nuova matrice.
Sintassi
cli::array<Value>^ to_array();
Osservazioni:
La funzione membro restituisce una matrice contenente la sequenza controllata. Viene usato per ottenere una copia della sequenza controllata in formato matrice.
Esempio
// 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)
Tipo di un elemento.
Sintassi
typedef Value value_type;
Osservazioni:
Il tipo è un sinonimo del parametro di modello Value.
Esempio
// 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)
Costruisce un oggetto contenitore.
Sintassi
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);
Parametri
count
Numero di elementi da inserire.
first
Inizio dell'intervallo da inserire.
last
Fine dell'intervallo da inserire.
right
Oggetto o un intervallo da inserire.
val
Valore dell'elemento da inserire.
Osservazioni:
Costruttore:
vector();
inizializza la sequenza controllata senza elementi. Viene usato per specificare una sequenza controllata iniziale vuota.
Costruttore:
vector(vector<Value>% right);
inizializza la sequenza controllata con la sequenza [right.begin(), right.end()). Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dal diritto dell'oggetto vettore.
Costruttore:
vector(vector<Value>^ right);
inizializza la sequenza controllata con la sequenza [right->begin(), right->end()). Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto vettore il cui handle è corretto.
Costruttore:
explicit vector(size_type count);
inizializza la sequenza controllata con gli elementi count ognuno con valore value_type(). Viene usato per riempire il contenitore con tutti gli elementi con il valore predefinito.
Costruttore:
vector(size_type count, value_type val);
inizializza la sequenza controllata con gli elementi count ognuno con valore val. È possibile usarlo per riempire il contenitore con tutti gli elementi con lo stesso valore.
Costruttore:
template<typename InIt>
vector(InIt first, InIt last);
inizializza la sequenza controllata con la sequenza [first, last). È possibile usarla per rendere la sequenza controllata una copia di un'altra sequenza.
Costruttore:
vector(System::Collections::Generic::IEnumerable<Value>^ right);
inizializza la sequenza controllata con la sequenza designata dal diritto dell'enumeratore. Viene usata per rendere la sequenza controllata una copia di un'altra sequenza descritta da un enumeratore.
Esempio
// 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)
Confronto tra vettori non uguali.
Sintassi
template<typename Value>
bool operator!=(vector<Value>% left,
vector<Value>% right);
Parametri
left
Contenitore sinistro da confrontare.
right
Contenitore destro da confrontare.
Osservazioni:
La funzione dell'operatore restituisce !(left == right). È possibile usarlo per verificare se left non è ordinato come a destra quando i due vettori vengono confrontati in base all'elemento.
Esempio
// 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< (vettore) (STL/CLR)
Vettore minore del confronto.
Sintassi
template<typename Value>
bool operator<(vector<Value>% left,
vector<Value>% right);
Parametri
left
Contenitore sinistro da confrontare.
right
Contenitore destro da confrontare.
Osservazioni:
La funzione dell'operatore restituisce true se, per la posizione i più bassa per la quale !(right[i] < left[i]) è anche true che left[i] < right[i]. In caso contrario, restituisce left->size() < right->size() You use it per verificare se left è ordinato prima di destra quando i due vettori vengono confrontati elemento per elemento.
Esempio
// 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<= (vettore) (STL/CLR)
Confronto tra vettore minore o uguale.
Sintassi
template<typename Value>
bool operator<=(vector<Value>% left,
vector<Value>% right);
Parametri
left
Contenitore sinistro da confrontare.
right
Contenitore destro da confrontare.
Osservazioni:
La funzione dell'operatore restituisce !(right < left). Viene usato per verificare se left non viene ordinato dopo destra quando i due vettori vengono confrontati per elemento.
Esempio
// 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)
Confronto tra vettori uguali.
Sintassi
template<typename Value>
bool operator==(vector<Value>% left,
vector<Value>% right);
Parametri
left
Contenitore sinistro da confrontare.
right
Contenitore destro da confrontare.
Osservazioni:
La funzione operator restituisce true solo se le sequenze controllate da sinistra e destra hanno la stessa lunghezza e, per ogni posizione i, left[i] ==right[i]. Viene usato per verificare se a sinistra viene ordinato lo stesso valore di destra quando i due vettori vengono confrontati in base all'elemento.
Esempio
// 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> (vettore) (STL/CLR)
Vettore maggiore del confronto.
Sintassi
template<typename Value>
bool operator>(vector<Value>% left,
vector<Value>% right);
Parametri
left
Contenitore sinistro da confrontare.
right
Contenitore destro da confrontare.
Osservazioni:
La funzione dell'operatore restituisce right<left. Viene usato per verificare se sinistra viene ordinata dopo destra quando i due vettori vengono confrontati in base all'elemento.
Esempio
// 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>= (vettore) (STL/CLR)
Confronto tra vettore maggiore o uguale.
Sintassi
template<typename Value>
bool operator>=(vector<Value>% left,
vector<Value>% right);
Parametri
left
Contenitore sinistro da confrontare.
right
Contenitore destro da confrontare.
Osservazioni:
La funzione dell'operatore restituisce !(left < right). È possibile usarlo per verificare se left non è ordinato prima di destra quando i due vettori vengono confrontati in base all'elemento.
Esempio
// 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
Commenti e suggerimenti
Presto disponibile: nel corso del 2024 verranno dismessi i problemi di GitHub come meccanismo di feedback per il contenuto e verranno sostituiti con un nuovo sistema di feedback. Per altre informazioni, vedere: https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per