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