Classe `vector`

Articolo
09/02/2023

La classe vettoriale libreria standard C++ è un modello di classe per i contenitori di sequenza. Un vettore archivia gli elementi di un determinato tipo in una disposizione lineare e consente l'accesso casuale rapido a qualsiasi elemento. Un vettore è il contenitore preferito per una sequenza quando le prestazioni di accesso casuale sono premium.

Sintassi

template <class Type, class Allocator = allocator<Type>>
class vector

Parametri

Type
Tipo di dati degli elementi da archiviare nel vettore.

Allocator
Il tipo che rappresenta l'oggetto allocatore archiviato che incapsula dettagli sull'allocazione del vettore e deallocazione della memoria. Questo argomento è facoltativo e il valore predefinito è allocator<Type>.

Osservazioni:

I vettori consentono inserimenti ed eliminazioni costanti nel tempo alla fine della sequenza. L'inserimento o l'eliminazione di elementi nel mezzo di un vettore richiede un tempo lineare. Il deque contenitore di classi è più veloce in caso di inserimenti ed eliminazioni all'inizio e alla fine di una sequenza. Il list contenitore di classi è più veloce in caso di inserimenti ed eliminazioni in qualsiasi posizione all'interno di una sequenza.

La riallocazione dei vettori si verifica quando una funzione membro deve aumentare la sequenza contenuta nell'oggetto vettore oltre la capacità di archiviazione corrente. Altre operazioni di inserimento e cancellazione possono modificare i vari indirizzi di archiviazione all'interno della sequenza. In questi casi, gli iteratori o i riferimenti che puntano alle parti modificate della sequenza diventeranno non validi. Se non si verifica alcuna riallocazione, restano validi solo gli iteratori e i riferimenti prima del punto di inserimento o eliminazione.

La vector<bool> classe è una specializzazione completa del vettore di modello di classe per gli elementi di tipo bool. Ha un allocatore per il tipo sottostante usato dalla specializzazione.

La vector<bool> classe reference è una classe annidata i cui oggetti possono fornire riferimenti a elementi (bit singoli) all'interno di un vector<bool> oggetto .

Membri

Costruttori

Nome	Descrizione
`vector`	Costruisce un vettore di dimensioni specifiche, con elementi di un valore specifico, con un oggetto `allocator` specifico o come copia di un altro vettore.

Typedef

Nome	Descrizione
`[allocator_type]`(#allocator_type)	Tipo che rappresenta la classe `allocator` per l'oggetto vector.
`const_iterator`	Tipo che fornisce un iteratore ad accesso casuale che può leggere un elemento `const` in un vettore.
`const_pointer`	Tipo che fornisce un puntatore a un elemento `const` di un vettore.
`const_reference`	Tipo che fornisce un riferimento a un `const` elemento archiviato in un vettore. Viene usato per la lettura e l'esecuzione di `const` operazioni.
`const_reverse_iterator`	Tipo che fornisce un iteratore ad accesso rapido che può leggere qualsiasi elemento `const` nel vettore.
`difference_type`	Tipo che offre la differenza tra gli indirizzi di due elementi in un vettore.
`iterator`	Tipo che fornisce un iteratore ad accesso casuale che può leggere o modificare qualsiasi elemento in un vettore.
`pointer`	Tipo che fornisce un puntatore a un elemento in un vettore.
`reference`	Tipo che fornisce un riferimento a un elemento archiviato in un vettore.
`reverse_iterator`	Tipo che fornisce un iteratore ad accesso casuale che può leggere o modificare qualsiasi elemento in un vettore inverso.
`size_type`	Tipo che conta il numero di elementi in un vettore.
`value_type`	Tipo che rappresenta il tipo di dati archiviati in un vettore.

Funzioni

Nome	Descrizione
`assign`	Cancella un vettore e copia gli elementi specificati nel vettore vuoto.
`at`	Restituisce un riferimento all'elemento in una posizione specificata nel vettore.
`back`	Restituisce un riferimento all'ultimo elemento del vettore.
`begin`	Restituisce un iteratore ad accesso casuale al primo elemento nel vettore.
`capacity`	Restituisce il numero di elementi che il vettore può contenere senza allocare più spazio di archiviazione.
`cbegin`	Restituisce un iteratore const ad accesso casuale al primo elemento nel vettore.
`cend`	Restituisce un iteratore const ad accesso casuale che punta appena oltre la fine del vettore.
`crbegin`	Restituisce un iteratore const che punta al primo elemento di un vettore invertito.
`crend`	Restituisce un iteratore const alla fine di un vettore invertito.
`clear`	Cancella gli elementi del vettore.
`data`	Restituisce un puntatore al primo elemento nel vettore.
`emplace`	Inserisce un elemento costruito sul posto nel vettore in una posizione specificata.
`emplace_back`	Aggiunge un elemento costruito sul posto alla fine del vettore.
`empty`	Verifica se il contenitore del vettore è vuoto.
`end`	Restituisce un iteratore ad accesso casuale che punta alla fine del vettore.
`erase`	Rimuove un elemento o un intervallo di elementi di un vettore dalle posizioni specificate.
`front`	Restituisce un riferimento al primo elemento di un vettore.
`get_allocator`	Restituisce un oggetto alla classe `allocator` usata da un vettore.
`insert`	Inserisce un elemento o molti elementi nel vettore in una posizione specificata.
`max_size`	Restituisce la lunghezza massima del vettore.
`pop_back`	Elimina l'elemento alla fine del vettore.
`push_back`	Aggiunge un elemento alla fine del vettore.
`rbegin`	Restituisce un iteratore al primo elemento in un vettore inverso.
`rend`	Restituisce un iteratore alla fine di un vettore invertito.
`reserve`	Riserva una lunghezza di archiviazione minima per un oggetto vector.
`resize`	Specifica una nuova dimensione per un vettore.
`shrink_to_fit`	Elimina la capacità in eccesso.
`size`	Restituisce il numero di elementi nel vettore.
`swap`	Scambia gli elementi di due vettori.

Operatori

Nome	Descrizione
`operator[]`	Restituisce un riferimento a un elemento di vettore in corrispondenza di una posizione specificata.
`operator=`	Sostituisce gli elementi del vettore con una copia di un altro vettore.

`allocator_type`

Tipo che rappresenta la classe allocator per l'oggetto vector.

typedef Allocator allocator_type;

Osservazioni:

allocator_type è un sinonimo per il parametro di modello Allocator.

Esempio

Vedere l'esempio per get_allocator un esempio che usa allocator_type.

`assign`

Cancella un vettore e copia gli elementi specificati nel vettore vuoto.

void assign(size_type count, const Type& value);
void assign(initializer_list<Type> init_list);

template <class InputIterator>
void assign(InputIterator first, InputIterator last);

Parametri

first
Posizione del primo elemento nell'intervallo di elementi da copiare.

last
Posizione del primo elemento oltre l'intervallo di elementi da copiare.

count
Numero di copie di un elemento da inserire nel vettore.

value
Valore dell'elemento da inserire nel vettore.

init_list
Oggetto initializer_list contenente gli elementi da inserire.

Osservazioni:

Prima di tutto, assign cancella tutti gli elementi esistenti in un vettore. Inserisce assign quindi un intervallo specificato di elementi dal vettore originale in un vettore oppure inserisce copie di un nuovo elemento valore specificato in un vettore.

Esempio

/ vector_assign.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> v1, v2, v3;

    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);
    v1.push_back(50);

    cout << "v1 = ";
    for (auto& v : v1){
        cout << v << " ";
    }
    cout << endl;

    v2.assign(v1.begin(), v1.end());
    cout << "v2 = ";
    for (auto& v : v2){
        cout << v << " ";
    }
    cout << endl;

    v3.assign(7, 4);
    cout << "v3 = ";
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;

    v3.assign({ 5, 6, 7 });
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;
}

`at`

Restituisce un riferimento all'elemento in una posizione specificata nel vettore.

reference at(size_type position);

const_reference at(size_type position) const;

Parametri

position
Numero di posizione o indice dell'elemento a cui fare riferimento nel vettore.

Valore restituito

Riferimento all'elemento con indice nell'argomento. Se position è maggiore della dimensione del vettore, at genera un'eccezione.

Osservazioni:

Se il valore restituito di at viene assegnato a un const_referenceoggetto , l'oggetto vettore non può essere modificato. Se il valore restituito di at viene assegnato a un oggetto reference, l'oggetto vector può essere modificato.

Esempio

// vector_at.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const int &i = v1.at( 0 );
   int &j = v1.at( 1 );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`back`

Restituisce un riferimento all'ultimo elemento del vettore.

reference back();

const_reference back() const;

Valore restituito

Ultimo elemento del vettore. Se il vettore è vuoto, il valore restituito non è definito.

Osservazioni:

Se il valore restituito di back viene assegnato a un const_referenceoggetto , l'oggetto vettore non può essere modificato. Se il valore restituito di back viene assegnato a un oggetto reference, l'oggetto vector può essere modificato.

Quando viene compilato usando _ITERATOR_DEBUG_LEVEL definito come 1 o 2, si verifica un errore di runtime se si tenta di accedere a un elemento in un vettore vuoto. Per altre informazioni, vedere Iteratori verificati.

Esempio

// vector_back.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main() {
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.back( );
   const int& ii = v1.front( );

   cout << "The last integer of v1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of v1 is "<< ii << endl;
}

`begin`

Restituisce un iteratore ad accesso casuale al primo elemento nel vettore.

const_iterator begin() const;

iterator begin();

Valore restituito

Iteratore ad accesso casuale che punta al primo elemento dell'oggetto vector o alla posizione successiva a un oggetto vector vuoto. Confrontare sempre il valore restituito con vector::end per assicurarsi che sia valido.

Osservazioni:

Se il valore restituito di begin viene assegnato a un vector::const_iteratoroggetto , l'oggetto vector non può essere modificato. Se il valore restituito di begin viene assegnato a un vector::iteratoroggetto , l'oggetto vector può essere modificato.

Esempio

// vector_begin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::iterator c1_Iter;
    vector<int>::const_iterator c1_cIter;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_Iter = c1.begin();
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_Iter = c1.begin();
    *c1_Iter = 20;
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    // The following line would be an error because iterator is const
    // *c1_cIter = 200;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`capacity`

Restituisce il numero di elementi che il vettore può contenere senza allocare più spazio di archiviazione.

size_type capacity() const;

Valore restituito

Lunghezza di archiviazione corrente allocata per il vettore.

Osservazioni:

La funzione resize membro sarà più efficiente se viene allocata memoria sufficiente per supportarla. Usare la funzione reserve membro per specificare la quantità di memoria allocata.

Esempio

// vector_capacity.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 1 );
   cout << "The length of storage allocated is "
        << v1.capacity( ) << "." << endl;

   v1.push_back( 2 );
   cout << "The length of storage allocated is now "
        << v1.capacity( ) << "." << endl;
}

The length of storage allocated is 1.
The length of storage allocated is now 2.

`cbegin`

Restituisce un iteratore const che punta al primo elemento dell'intervallo.

const_iterator cbegin() const;

Valore restituito

Iteratore ad accesso casuale const che punta al primo elemento dell'intervallo o alla posizione oltre la fine di un intervallo vuoto (per un intervallo vuoto, cbegin() == cend()).

Osservazioni:

Con il valore restituito di cbegin, gli elementi nell'intervallo non possono essere modificati.

È possibile usare questa funzione membro anziché la funzione membro begin() per garantire che il valore restituito sia const_iterator. In genere, viene usato in con la parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta begin() e cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

Restituisce un const iteratore passato che punta all'elemento che segue l'ultimo elemento del vettore.

const_iterator cend() const;

Valore restituito

Iteratore const passato per il vettore. Punta all'elemento che segue l'ultimo elemento del vettore. L'elemento è un segnaposto e non deve essere dereferenziato. Usarlo solo per i confronti. Se il vettore è vuoto, vector::cend() == vector::cbegin().

Osservazioni:

cend viene utilizzato per verificare se un iteratore ha superato la fine del relativo intervallo.

È possibile usare questa funzione membro anziché la funzione membro end() per garantire che il valore restituito sia const_iterator. In genere, viene usato con la parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta end() e cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Il valore restituito da cend non deve essere dereferenziato. Usarlo solo per i confronti.

`clear`

Cancella gli elementi del vettore.

void clear();

Esempio

// vector_clear.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "The size of v1 is " << v1.size( ) << endl;
   v1.clear( );
   cout << "The size of v1 after clearing is " << v1.size( ) << endl;
}

The size of v1 is 3
The size of v1 after clearing is 0

`const_iterator`

Tipo che fornisce un iteratore ad accesso casuale che può leggere un elemento const in un vettore.

typedef implementation-defined const_iterator;

Osservazioni:

Non è possibile usare un tipo const_iterator per modificare il valore di un elemento.

Esempio

Vedere l'esempio relativo a back per indicazioni su come usare const_iterator.

`const_pointer`

Tipo che fornisce un puntatore a un elemento const di un vettore.

typedef typename Allocator::const_pointer const_pointer;

Osservazioni:

Non è possibile usare un tipo const_pointer per modificare il valore di un elemento.

Per accedere a un elemento del vettore viene in genere usato un oggetto iterator.

`const_reference`

Tipo che fornisce un riferimento a un const elemento archiviato in un vettore. Viene usato per la lettura e l'esecuzione di const operazioni.

typedef typename Allocator::const_reference const_reference;

Osservazioni:

Non è possibile usare un tipo const_reference per modificare il valore di un elemento.

Esempio

// vector_const_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const vector <int> v2 = v1;
   const int &i = v2.front( );
   const int &j = v2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error as v2 is const
   // v2.push_back( 30 );
}

The first element is 10
The second element is 20

`const_reverse_iterator`

Tipo che fornisce un iteratore ad accesso rapido che può leggere qualsiasi elemento const nel vettore.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Osservazioni:

Un tipo const_reverse_iterator non può modificare il valore di un elemento e viene usato per scorrere il vettore inverso.

Esempio

Vedere rbegin per un esempio di come dichiarare e usare un iteratore.

`crbegin`

Restituisce un iteratore const che punta al primo elemento di un vettore invertito.

const_reverse_iterator crbegin() const;

Valore restituito

Iteratore ad accesso casuale const inverso che punta al primo elemento in un oggetto invertito vector o che punta a ciò che era stato l'ultimo elemento nell'oggetto non invertito vector.

Osservazioni:

Con il valore restituito di crbegin, l'oggetto vector non può essere modificato.

Esempio

// vector_crbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`crend`

Restituisce un const iteratore inverso passato che punta all'elemento che segue l'ultimo elemento del vettore invertito.

const_reverse_iterator crend() const;

Valore restituito

Iteratore const inverso passato alla fine per il vettore invertito. Punta all'elemento che segue l'ultimo elemento del vettore invertito, che corrisponde all'elemento prima del primo elemento del vettore non invertito. L'elemento è un segnaposto e non deve essere dereferenziato. Usarlo solo per i confronti.

Osservazioni:

crend viene usato con un oggetto invertito vector esattamente come vector::cend viene usato con un oggetto vector.

Con il valore restituito di crend (adeguato decrementato), l'oggetto vector non può essere modificato.

crend può essere usato per verificare se un iteratore inverso ha raggiunto la fine dell'oggetto vector.

Il valore restituito da crend non deve essere dereferenziato. Usarlo solo per i confronti.

Esempio

// vector_crend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`data`

Restituisce un puntatore al primo elemento nel vettore.

const_pointer data() const;

pointer data();

Valore restituito

Puntatore al primo elemento nell'oggetto vector o alla posizione successiva a un oggetto vuoto vector.

Esempio

// vector_data.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::pointer c1_ptr;
    vector<int>::const_pointer c1_cPtr;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_cPtr = c1.data();
    for (size_t n = c1.size(); 0 < n; --n, c1_cPtr++)
    {
        cout << " " << *c1_cPtr;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_ptr = c1.data();
    *c1_ptr = 20;
    for (size_t n = c1.size(); 0 < n; --n, c1_ptr++)
    {
        cout << " " << *c1_ptr;
    }
    cout << endl;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`difference_type`

Tipo che fornisce la differenza tra due iteratori che fanno riferimento agli elementi all'interno dello stesso vettore.

typedef typename Allocator::difference_type difference_type;

Osservazioni:

Un oggetto difference_type può anche essere descritto come il numero di elementi tra due puntatori, poiché un puntatore a un elemento ne contiene l'indirizzo.

Per accedere a un elemento del vettore viene in genere usato un oggetto iterator.

Esempio

// vector_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <vector>
#include <algorithm>

int main( )
{
   using namespace std;

   vector <int> c1;
   vector <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

   vector <int>::difference_type   df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}

The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

`emplace`

Inserisce un elemento costruito sul posto nel vettore in una posizione specificata.

template <class... Types>
iterator emplace(
    const_iterator position,
    Types&&... args);

Parametri

position
Posizione nell'oggetto in vector cui viene inserito il primo elemento.

args
Argomenti del costruttore. La funzione deduce di quale costruttore eseguire l'overload per richiamare il costruttore in base agli argomenti forniti.

Valore restituito

La funzione restituisce un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento nell'oggetto vector.

Osservazioni:

Qualsiasi operazione di inserimento può essere costosa, vedere vector la classe per una descrizione delle vector prestazioni.

Esempio

// vector_emplace.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
vv1[0] = 10 20 30

`emplace_back`

Aggiunge un elemento costruito sul posto alla fine del vettore.

template <class... Types>
void emplace_back(Types&&... args);

Parametri

args
Argomenti del costruttore. La funzione deduce di quale costruttore eseguire l'overload per richiamare il costruttore in base agli argomenti forniti.

Esempio

#include <vector>
struct obj
{
   obj(int, double) {}
};

int main()
{
   std::vector<obj> v;
   v.emplace_back(1, 3.14); // obj in created in place in the vector
}

`empty`

Verifica se il vettore è vuoto.

bool empty() const;

Valore restituito

true se il vettore è vuoto; false se il vettore non è vuoto.

Esempio

// vector_empty.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );

   if ( v1.empty( ) )
      cout << "The vector is empty." << endl;
   else
      cout << "The vector is not empty." << endl;
}

The vector is not empty.

`end`

Restituisce un iteratore passato che punta all'elemento che segue l'ultimo elemento del vettore.

iterator end();

const_iterator end() const;

Valore restituito

Iteratore passato per il vettore. Punta all'elemento che segue l'ultimo elemento del vettore. L'elemento è un segnaposto e non deve essere dereferenziato. Usarlo solo per i confronti. Se il vettore è vuoto, vector::end() == vector::begin().

Osservazioni:

Se il valore restituito di end viene assegnato a una variabile di tipo const_iterator, l'oggetto vettore non può essere modificato. Se il valore restituito di end viene assegnato a una variabile di tipo iterator, l'oggetto vettore può essere modificato.

Esempio

// vector_end.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>
int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_Iter = v1.begin( ) ; v1_Iter != v1.end( ) ; v1_Iter++ )
      cout << *v1_Iter << endl;
}

1
2

`erase`

Rimuove un elemento o un intervallo di elementi di un vettore dalle posizioni specificate.

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

Parametri

position
Posizione dell'elemento da rimuovere dal vettore.

first
Posizione del primo elemento rimosso dal vettore.

last
Posizione oltre l'ultimo elemento rimosso dal vettore.

Valore restituito

Iteratore che definisce il primo elemento rimanente oltre tutti gli elementi rimossi o puntatore alla fine del vettore se tale elemento non esiste.

Esempio

// vector_erase.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );
   v1.push_back( 40 );
   v1.push_back( 50 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) + 1, v1.begin( ) + 3 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
}

v1 = 10 20 30 40 50
v1 = 20 30 40 50
v1 = 20 50

`front`

Restituisce un riferimento al primo elemento di un vettore.

reference front();

const_reference front() const;

Valore restituito

Riferimento al primo elemento dell'oggetto vector. Se il vettore è vuoto, il valore restituito non è definito.

Osservazioni:

Se il valore restituito di front viene assegnato a un const_referenceoggetto , l'oggetto vettore non può essere modificato. Se il valore restituito di front viene assegnato a un oggetto reference, l'oggetto vector può essere modificato.

Esempio

// vector_front.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.front( );
   const int& ii = v1.front( );

   cout << "The first integer of v1 is "<< i << endl;
   // by incrementing i, we move the front reference to the second element
   i++;
   cout << "Now, the first integer of v1 is "<< i << endl;
}

`get_allocator`

Restituisce una copia dell'oggetto allocatore usato per costruire il vettore.

Allocator get_allocator() const;

Valore restituito

Allocatore usato dal vettore.

Osservazioni:

Gli allocatori per la classe vector specificano il modo in cui la classe gestisce l'archiviazione. Gli allocatori predefiniti acclusi alle classi contenitore della libreria standard C++ sono sufficienti per la maggior parte delle esigenze di programmazione. La scrittura e l'uso di una classe allocatore personalizzata è una funzionalità C++ avanzata.

Esempio

// vector_get_allocator.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects that use the default allocator.
   vector<int> v1;
   vector<int, allocator<int> > v2 = vector<int, allocator<int> >(allocator<int>( )) ;

   // v3 will use the same allocator class as v1
   vector <int> v3( v1.get_allocator( ) );

   vector<int>::allocator_type xvec = v3.get_allocator( );
   // You can now call functions on the allocator class used by vec
}

`insert`

Inserisce un elemento, o molti elementi, o un intervallo di elementi nel vettore in una posizione specificata.

iterator insert(
    const_iterator position,
    const Type& value);

iterator insert(
    const_iterator position,
    Type&& value);

void insert(
    const_iterator position,
    size_type count,
    const Type& value);

template <class InputIterator>
void insert(
    const_iterator position,
    InputIterator first,
    InputIterator last);

Parametri

position
Posizione nel vettore in cui viene inserito il primo elemento.

value
Valore dell'elemento da inserire nel vettore.

count
Numero di elementi da inserire nel vettore.

first
Posizione del primo elemento nell'intervallo di elementi da copiare.

last
Posizione del primo elemento oltre l'intervallo di elementi da copiare.

Valore restituito

Le prime due funzioni insert restituiscono un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento nel vettore.

Osservazioni:

Come condizione preliminare, first e last non devono essere iteratori all'interno del vettore; in caso contrario, il comportamento sarà indefinito. Qualsiasi operazione di inserimento può essere costosa, vedere vector la classe per una descrizione delle vector prestazioni.

Esempio

// vector_insert.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.insert( v1.begin( ) + 1, 40 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
   v1.insert( v1.begin( ) + 2, 4, 50 );

   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   const auto v2 = v1;
   v1.insert( v1.begin( )+1, v2.begin( )+2, v2.begin( )+4 );
   cout << "v1 =";
   for (Iter = v1.begin( ); Iter != v1.end( ); Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.insert( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
v1 = 10 40 20 30
v1 = 10 40 50 50 50 50 20 30
v1 = 10 50 50 40 50 50 50 50 20 30
vv1[0] = 10 50 50 40 50 50 50 50 20 30

`iterator`

Tipo che fornisce un iteratore ad accesso casuale che può leggere o modificare qualsiasi elemento in un vettore.

typedef implementation-defined iterator;

Osservazioni:

È possibile utilizzare un tipo iterator per modificare il valore di un elemento.

Esempio

Vedere l'esempio per begin.

`max_size`

Restituisce la lunghezza massima del vettore.

size_type max_size() const;

Valore restituito

Lunghezza massima possibile del vettore.

Esempio

// vector_max_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   i = v1.max_size( );
   cout << "The maximum possible length of the vector is " << i << "." << endl;
}

`operator[]`

Restituisce un riferimento a un elemento di vettore in corrispondenza di una posizione specificata.

reference operator[](size_type position);

const_reference operator[](size_type position) const;

Parametri

position
Posizione dell'elemento di vettore.

Valore restituito

Se la posizione specificata è maggiore o uguale alla dimensione del contenitore, il risultato sarà non definito.

Osservazioni:

Se il valore restituito di operator[] viene assegnato a un const_referenceoggetto , l'oggetto vettore non può essere modificato. Se il valore restituito di operator[] viene assegnato a un riferimento, l'oggetto vector può essere modificato.

Quando viene compilato usando _ITERATOR_DEBUG_LEVEL definito come 1 o 2, si verifica un errore di runtime se si tenta di accedere a un elemento al di fuori dei limiti del vettore. Per altre informazioni, vedere Iteratori verificati.

Esempio

// vector_op_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   int& i = v1[1];
   cout << "The second integer of v1 is " << i << endl;
}

`operator=`

Sostituisce gli elementi del vettore con una copia di un altro vettore.

vector& operator=(const vector& right);

vector& operator=(vector&& right);

Parametri

right
Oggetto vector copiato in vector.

Osservazioni:

Dopo la cancellazione di tutti gli elementi esistenti in un oggetto vector, operator= copia o sposta il contenuto di right nell'oggetto vector.

Esempio

// vector_operator_as.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int> v1, v2, v3;
   vector<int>::iterator iter;

   v1.push_back(10);
   v1.push_back(20);
   v1.push_back(30);
   v1.push_back(40);
   v1.push_back(50);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
}

`pointer`

Tipo che fornisce un puntatore a un elemento in un vettore.

typedef typename Allocator::pointer pointer;

Osservazioni:

È possibile utilizzare un tipo pointer per modificare il valore di un elemento.

Esempio

// vector_pointer.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
    using namespace std;
    vector<int> v;
    v.push_back( 11 );
    v.push_back( 22 );

    vector<int>::pointer ptr = &v[0];
    cout << *ptr << endl;
    ptr++;
    cout << *ptr << endl;
    *ptr = 44;
    cout << *ptr << endl;
}

11
22
44

`pop_back`

Elimina l'elemento alla fine del vettore.

void pop_back();

Osservazioni:

Per un esempio di codice, vedere vector::push_back().

`push_back`

Aggiunge un elemento alla fine del vettore.

void push_back(const T& value);

void push_back(T&& value);

Parametri

value
Valore da assegnare all'elemento aggiunto alla fine del vettore.

Esempio

// compile with: /EHsc /W4
#include <vector>
#include <iostream>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << "  " << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

int main()
{
    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(10 + i);
    }

    cout << "vector data: " << endl;
    print_collection(v);

    // pop_back() until it's empty, printing the last element as we go
    while (v.begin() != v.end()) {
        cout << "v.back(): "; print_elem(v.back()); cout << endl;
        v.pop_back();
    }
}

`rbegin`

Restituisce un iteratore al primo elemento in un vettore inverso.

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

Valore restituito

Iteratore inverso ad accesso casuale che punta al primo elemento di un oggetto vector invertito (o che punta a quello che era stato l'ultimo elemento nell'oggetto vector non invertito).

Osservazioni:

Se il valore restituito di rbegin viene assegnato a un const_reverse_iteratoroggetto , l'oggetto vettore non può essere modificato. Se il valore restituito di rbegin viene assegnato a un oggetto reverse_iterator, l'oggetto vector può essere modificato.

Esempio

// vector_rbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.rbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`reference`

Tipo che fornisce un riferimento a un elemento archiviato in un vettore.

typedef typename Allocator::reference reference;

Esempio

Vedere at per un esempio di come usare reference nella classe vector.

`rend`

Restituisce un iteratore inverso passato che punta all'elemento che segue l'ultimo elemento del vettore invertito.

const_reverse_iterator rend() const;
reverse_iterator rend();

Valore restituito

Iteratore inverso passato alla fine per il vettore invertito. Punta all'elemento che segue l'ultimo elemento del vettore invertito, che corrisponde all'elemento prima del primo elemento del vettore non invertito. L'elemento è un segnaposto e non deve essere dereferenziato. Usarlo solo per i confronti.

Osservazioni:

rend viene usato con un vettore invertito esattamente come end viene usato con un vettore.

Se il valore restituito di rend viene assegnato a un const_reverse_iteratoroggetto , l'oggetto vettore non può essere modificato. Se il valore restituito di rend viene assegnato a un oggetto reverse_iterator, l'oggetto vector può essere modificato.

rend può essere usato per verificare se un iteratore inverso ha raggiunto la fine del relativo vettore.

Il valore restituito da rend non deve essere dereferenziato. Usarlo solo per i confronti.

Esempio

// vector_rend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`reserve`

Riserva una lunghezza di archiviazione minima per un oggetto vettore, allocando lo spazio se necessario.

void reserve(size_type count);

Parametri

count
Lunghezza di archiviazione minima da allocare per il vettore.

Esempio

// vector_reserve.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20

`resize`

Specifica una nuova dimensione per un vettore.

void resize(size_type new_size);
void resize(size_type new_size, Type value);

Parametri

new_size
La nuova dimensione del vettore.

value
Valore di inizializzazione dei nuovi elementi aggiunti al vettore se la nuova dimensione è maggiore di quella originaria. Se il valore viene omesso, i nuovi oggetti usano il proprio costruttore predefinito.

Osservazioni:

Se le dimensioni del contenitore sono inferiori alle dimensioni richieste, new_size, resize aggiunge elementi al vettore fino a raggiungere le dimensioni richieste. Quando le dimensioni del contenitore sono maggiori delle dimensioni richieste, resize elimina gli elementi più vicini alla fine del contenitore fino a raggiungere le dimensioni new_size. Non viene eseguita alcuna azione se le dimensioni presenti del contenitore corrispondono alle dimensioni richieste.

size riflette le dimensioni correnti del vettore.

Esempio

// vectorsizing.cpp
// compile with: /EHsc /W4
// Illustrates vector::reserve, vector::max_size,
// vector::resize, vector::resize, and vector::capacity.
//
// Functions:
//
//    vector::max_size - Returns maximum number of elements vector could
//                       hold.
//
//    vector::capacity - Returns number of elements for which memory has
//                       been allocated.
//
//    vector::size - Returns number of elements in the vector.
//
//    vector::resize - Reallocates memory for vector, preserves its
//                     contents if new size is larger than existing size.
//
//    vector::reserve - Allocates elements for vector to ensure a minimum
//                      size, preserving its contents if the new size is
//                      larger than existing size.
//
//    vector::push_back - Appends (inserts) an element to the end of a
//                        vector, allocating memory for it if necessary.
//
//////////////////////////////////////////////////////////////////////

// The debugger cannot handle symbols more than 255 characters long.
// The C++ Standard Library often creates symbols longer than that.
// The warning can be disabled:
//#pragma warning(disable:4786)

#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c) {
    cout << s;

    for (const auto& e : c) {
        cout << e << " ";
    }
    cout << endl;
}

void printvstats(const vector<int>& v) {
    cout << "   the vector's size is: " << v.size() << endl;
    cout << "   the vector's capacity is: " << v.capacity() << endl;
    cout << "   the vector's maximum size is: " << v.max_size() << endl;
}

int main()
{
    // declare a vector that begins with 0 elements.
    vector<int> v;

    // Show statistics about vector.
    cout << endl << "After declaring an empty vector:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Add one element to the end of the vector.
    v.push_back(-1);
    cout << endl << "After adding an element:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    for (int i = 1; i < 10; ++i) {
        v.push_back(i);
    }
    cout << endl << "After adding 10 elements:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(6);
    cout << endl << "After resizing to 6 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(9, 999);
    cout << endl << "After resizing to 9 elements with an initialization value of 999:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(12);
    cout << endl << "After resizing to 12 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Ensure there's room for at least 1000 elements.
    v.reserve(1000);
    cout << endl << "After vector::reserve(1000):" << endl;
    printvstats(v);

    // Ensure there's room for at least 2000 elements.
    v.resize(2000);
    cout << endl << "After vector::resize(2000):" << endl;
    printvstats(v);
}

`reverse_iterator`

Tipo che fornisce un iteratore ad accesso casuale che può leggere o modificare qualsiasi elemento in un vettore inverso.

typedef std::reverse_iterator<iterator> reverse_iterator;

Osservazioni:

Un tipo reverse_iterator viene usato per eseguire l'iterazione sul vettore in ordine inverso.

Esempio

Vedere l'esempio per rbegin.

`shrink_to_fit`

Elimina la capacità in eccesso.

void shrink_to_fit();

Esempio

// vector_shrink_to_fit.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.shrink_to_fit();
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20
Current capacity of v1 = 1

`size`

Restituisce il numero di elementi nel vettore.

size_type size() const;

Valore restituito

Lunghezza corrente del vettore.

Esempio

// vector_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   v1.push_back( 1 );
   i = v1.size( );
   cout << "Vector length is " << i << "." << endl;

   v1.push_back( 2 );
   i = v1.size( );
   cout << "Vector length is now " << i << "." << endl;
}

Vector length is 1.
Vector length is now 2.

`size_type`

Tipo che conta il numero di elementi in un vettore.

typedef typename Allocator::size_type size_type;

Esempio

Vedere l'esempio per capacity.

`swap`

Scambia gli elementi di due vettori.

void swap(
    vector<Type, Allocator>& right);

friend void swap(
    vector<Type, Allocator>& left,
    vector<Type, Allocator>& right);

Parametri

right
Vettore che fornisce gli elementi da scambiare. In alternativa, un vettore i cui elementi devono essere scambiati con gli elementi nel vettore left.

left
Vettore i cui elementi devono essere scambiati con gli elementi nel vettore right.

Esempio

// vector_swap.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1, v2;

   v1.push_back( 1 );
   v1.push_back( 2 );
   v1.push_back( 3 );

   v2.push_back( 10 );
   v2.push_back( 20 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
   cout << endl;

   v1.swap( v2 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
}

The number of elements in v1 = 3
The number of elements in v2 = 2

The number of elements in v1 = 2
The number of elements in v2 = 3

`value_type`

Tipo che rappresenta il tipo di dati archiviati in un vettore.

typedef typename Allocator::value_type value_type;

Osservazioni:

value_type è un sinonimo per il parametro di modello Type.

Esempio

// vector_value_type.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

`vector`

Costruisce un vettore. Gli overload costruiscono un vettore di una dimensione specifica o con elementi di un valore specifico. Oppure, come copia di tutto o parte di un altro vettore. Alcuni overload consentono anche di specificare l'allocatore da usare.

vector();
explicit vector(const Allocator& allocator);
explicit vector(size_type count);
vector(size_type count, const Type& value);
vector(size_type count, const Type& value, const Allocator& allocator);

vector(const vector& source);
vector(vector&& source);
vector(initializer_list<Type> init_list, const Allocator& allocator);

template <class InputIterator>
vector(InputIterator first, InputIterator last);
template <class InputIterator>
vector(InputIterator first, InputIterator last, const Allocator& allocator);

Parametri

allocator
Classe Allocator da usare con questo oggetto. get_allocator restituisce la classe allocatore per l'oggetto .

count
Numero di elementi del vettore costruito.

value
Valore degli elementi del vettore costruito.

source
Vettore di cui il vettore costruito deve essere una copia.

first
Posizione del primo elemento nell'intervallo di elementi da copiare.

last
Posizione del primo elemento oltre l'intervallo di elementi da copiare.

init_list
Oggetto initializer_list contenente gli elementi da copiare.

Osservazioni:

Tutti i costruttori archiviano un oggetto allocatore (allocator) e inizializzano il vettore.

I primi due costruttori specificano un vettore iniziale vuoto. Il secondo costruttore specifica in modo esplicito il tipo di allocatore (allocator) da usare.

Tramite il terzo costruttore viene specificata una ripetizione di un numero indicato (count) di elementi del valore predefinito per la classe Type.

Il quarto e il quinto costruttore specificano una ripetizione di elementi (count) di valore value.

Il sesto costruttore specifica una copia del vettore source.

Il settimo costruttore sposta il vettore source.

L'ottavo costruttore usa un oggetto initializer_list per specificare gli elementi.

Il nono e il decimo costruttore copiano l'intervallo [first, last) di un vettore.

Esempio

// vector_ctor.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector <int>::iterator v1_Iter, v2_Iter, v3_Iter, v4_Iter, v5_Iter, v6_Iter;

    // Create an empty vector v0
    vector <int> v0;

    // Create a vector v1 with 3 elements of default value 0
    vector <int> v1(3);

    // Create a vector v2 with 5 elements of value 2
    vector <int> v2(5, 2);

    // Create a vector v3 with 3 elements of value 1 and with the allocator
    // of vector v2
    vector <int> v3(3, 1, v2.get_allocator());

    // Create a copy, vector v4, of vector v2
    vector <int> v4(v2);

    // Create a new temporary vector for demonstrating copying ranges
    vector <int> v5(5);
    for (auto i : v5) {
        v5[i] = i;
    }

    // Create a vector v6 by copying the range v5[ first,  last)
    vector <int> v6(v5.begin() + 1, v5.begin() + 3);

    cout << "v1 =";
    for (auto& v : v1){
        cout << " " << v;
    }
    cout << endl;

    cout << "v2 =";
    for (auto& v : v2){
        cout << " " << v;
    }
    cout << endl;

    cout << "v3 =";
    for (auto& v : v3){
        cout << " " << v;
    }
    cout << endl;
    cout << "v4 =";
    for (auto& v : v4){
        cout << " " << v;
    }
    cout << endl;

    cout << "v5 =";
    for (auto& v : v5){
        cout << " " << v;
    }
    cout << endl;

    cout << "v6 =";
    for (auto& v : v6){
        cout << " " << v;
    }
    cout << endl;

    // Move vector v2 to vector v7
    vector <int> v7(move(v2));
    vector <int>::iterator v7_Iter;

    cout << "v7 =";
    for (auto& v : v7){
        cout << " " << v;
    }
    cout << endl;

    cout << "v8 =";
    vector<int> v8{ { 1, 2, 3, 4 } };
    for (auto& v : v8){
        cout << " " << v ;
    }
    cout << endl;
}

v1 = 0 0 0
v2 = 2 2 2 2 2
v3 = 1 1 1
v4 = 2 2 2 2 2
v5 = 0 0 0 0 0
v6 = 0 0
v7 = 2 2 2 2 2
v8 = 1 2 3 4

Vedi anche

Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)
Informazioni di riferimento per la libreria standard C++

Condividi tramite

Classe vector

Sintassi

Parametri

Osservazioni:

Membri

Costruttori

Typedef

Funzioni

Operatori

allocator_type

Osservazioni:

Esempio

assign

Parametri

Osservazioni:

Esempio

at

Parametri

Valore restituito

Osservazioni:

Esempio

back

Valore restituito

Osservazioni:

Esempio

begin

Valore restituito

Osservazioni:

Esempio

capacity

Valore restituito

Osservazioni:

Esempio

cbegin

Valore restituito

Osservazioni:

cend

Valore restituito

Osservazioni:

clear

Esempio

const_iterator

Osservazioni:

Esempio

const_pointer

Osservazioni:

const_reference

Osservazioni:

Esempio

const_reverse_iterator

Osservazioni:

Esempio

crbegin

Valore restituito

Osservazioni:

Esempio

crend

Valore restituito

Osservazioni:

Esempio

data

Valore restituito

Esempio

difference_type

Osservazioni:

Esempio

emplace

Parametri

Valore restituito

Osservazioni:

Esempio

emplace_back

Parametri

Esempio

empty

Valore restituito

Esempio

end

Valore restituito

Classe `vector`

`allocator_type`

`assign`

`at`

`back`

`begin`

`capacity`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`data`

`difference_type`

`emplace`

`emplace_back`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`push_back`

`rbegin`

`reference`

`rend`

`reserve`

`resize`

`reverse_iterator`

`shrink_to_fit`

`size`

`size_type`