Come usare C++ Vector

How Use C Vector

introduzione

Un array è una serie di stessi tipi di oggetti in locazioni di memoria consecutive. Un array non può aumentare o ridursi in lunghezza. Un vettore è come un array, ma la sua lunghezza può essere aumentata o ridotta. Un vettore, quindi, ha molte più operazioni di un array.

C++ ha molte librerie, che formano tutte la C++ Standard Library. Una di queste librerie è la libreria contenitore. Un contenitore è una raccolta di oggetti e determinate operazioni possono essere eseguite sulla raccolta. I contenitori C++ possono essere raggruppati in due insiemi: contenitori di sequenza e contenitori associativi. I contenitori di sequenza sono vector, array (non lo stesso array discusso in precedenza), deque, forward_list e list. Si tratta di raccolte diverse (strutture di dati simili a array) e ognuna offre compromessi distinti.



Qualsiasi programmatore dovrebbe sapere come decidere se utilizzare un vettore, un array, un deque, un forward_list o un elenco. Quando un programmatore necessita di una struttura che richiede più operazioni di quelle associate a un array ordinario, l'array ordinario non dovrebbe essere utilizzato.



Se l'attività prevede inserimenti ed eliminazioni frequenti nel mezzo della sequenza, è necessario utilizzare un elenco o forward_list. Se l'attività prevede inserimenti ed eliminazioni frequenti all'inizio o alla fine di una sequenza, è necessario utilizzare un deque. Un vettore dovrebbe essere usato quando questo tipo di operazioni non sono richieste.



Questo articolo mostra come usare il vettore C++. Avrai bisogno di una certa conoscenza dei puntatori, dei riferimenti e degli array C++ per comprendere questo articolo.

Classe e oggetti

Una classe è un insieme di variabili e funzioni che lavorano insieme, in cui le variabili non hanno valori assegnati. Quando i valori sono assegnati alle variabili, una classe diventa un oggetto. Valori diversi dati alla stessa classe danno come risultato oggetti diversi; in altre parole, oggetti diversi possono appartenere alla stessa classe ma avere valori diversi. La creazione di un oggetto da una classe è anche nota come istanziazione dell'oggetto.

Il termine vettore descrive una classe. Un oggetto creato da un vettore ha un nome scelto dal programmatore.



Una funzione che appartiene a una classe è necessaria per istanziare un oggetto dalla classe. In C++, quella funzione ha lo stesso nome del nome della classe. Diversi oggetti creati (istanziati) dalla classe hanno nomi distinti assegnati a ciascuno di essi dal programmatore.

Creare un oggetto da una classe significa costruire l'oggetto; significa anche istanziare l'oggetto.

La classe vettoriale

La classe vector è già stata definita ed è nella libreria. Per utilizzare la classe vector, un programmatore deve includere l'intestazione vector nel file con la seguente direttiva di preelaborazione:

#includere

Una volta inclusa l'intestazione, tutte le funzioni vettoriali (membri dati e funzioni membro) diventano accessibili. Per utilizzare l'oggetto conteggio per inviare i dati al terminale (console), è necessario includere anche l'intestazione dell'oggetto. Per scrivere un programma con il vettore, come minimo, devono essere incluse le seguenti intestazioni:

#includere
#includere

Istanziazione di un vettore

intpippo[10];

Sopra c'è la dichiarazione di un array con il nome foo e il numero di elementi 10. Questo è un array di interi. La dichiarazione di un vettore è simile. Per un vettore, il numero di elementi è facoltativo, poiché la lunghezza del vettore può aumentare o diminuire.

A questo punto del programma, la classe vettoriale è già stata definita nella libreria e l'intestazione è stata inclusa. Il vettore può essere istanziato come segue:

ore::vettore <int>vtr(8);

Qui, il vettore è della funzione di costruzione speciale. Il tipo di dati che il vettore manterrà è int, tra parentesi angolari. Il termine vtr è il nome scelto dal programmatore per il vettore. Infine, 8, tra parentesi, è il numero provvisorio di interi che avrà il vettore.

Il termine std sta per spazio dei nomi standard. Questo termine deve essere seguito da due punti, in questo contesto. Chiunque può scrivere la propria libreria di classi vettoriali e usarla. Tuttavia, C++ ha già una libreria standard con nomi standard, incluso vector. Per utilizzare un nome standard, il nome standard deve essere preceduto da std:: . Per evitare di digitare std:: ogni volta nel programma per un nome standard, il file del programma può iniziare come segue:

#includere
#includere
usando lo spazio dei nomi std;

Sovraccaricare una funzione

Quando due o più firme di funzione diverse hanno lo stesso nome, si dice che quel nome è sovraccarico. Quando viene chiamata una funzione, il numero e il tipo di argomenti determinano quale funzione viene eseguita.

Costruire un vettore

Costruire un vettore significa istanziare (creare) un oggetto vettoriale. La funzione di costruzione viene sovraccaricata come segue:

nome del vettore

Questo crea un vettore di lunghezza zero e di tipo T. L'istruzione seguente crea un vettore di lunghezza zero del tipo float con il nome vtr:

vettore<galleggiante>vtr;

nome del vettore (n)

Questo crea un vettore con n elementi di tipo T. Un'istruzione per questo vettore con quattro elementi float è la seguente:

vettore<galleggiante>vtr(4);

nome del vettore (n, t)

Questo crea un vettore di n elementi inizializzati al valore t. La seguente istruzione crea un vettore di 5 elementi, dove ogni elemento ha il valore 3.4:

vettore<galleggiante>vtr(5, 3.4);

Costruire con l'inizializzazione

Un vettore può essere costruito (creato) e inizializzato allo stesso tempo, in uno dei due modi seguenti:

vettore<galleggiante>vtr= {1.1, 2.2, 3.3, 4.4};

o

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};

Nota che non ci sono parentesi subito dopo il nome dell'oggetto. Le parentesi usate subito dopo il nome dell'oggetto dovrebbero avere l'elenco degli inizializzatori, come segue:

vettore<galleggiante>vtr({1.1, 2.2, 3.3, 4.4});

Un vettore può essere costruito e inizializzato in seguito con l'elenco degli inizializzatori. In questo caso, le parentesi non verranno utilizzate:

vettore<galleggiante>vtr;
vtr= {1.1, 2.2, 3.3, 4.4};

vettore V2 (V1)

Questo è un costruttore di copie. Crea un vettore V2 come copia del vettore V1. Il codice seguente lo illustra:

vettore<galleggiante>vtr1(5, 3.4);
vettore<galleggiante>vtr2(vtr1);

Assegnazione di un vettore durante la costruzione

Durante la costruzione è possibile creare un vettore vuoto mentre gliene viene assegnato un altro, come segue:

vettore<galleggiante>vtr1{1.1, 2.2, 3.3, 4.4};
vettore<galleggiante>vtr2=vtr1;

La seconda affermazione equivale a:

vettore<galleggiante>vtr2= {1.1, 2.2, 3.3, 4.4};

const vettoriale

Un vettore const è un vettore i cui elementi non possono essere modificati. I valori in questo vettore sono di sola lettura. Una volta creato, il vettore appare come segue:

costvettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};

In questo tipo di vettore, nessun elemento può essere aggiunto o rimosso. Inoltre, nessun valore può essere modificato.

Costruire con Iterator

Un modello fornisce una rappresentazione generica per un tipo di dati. Un iteratore fornisce una rappresentazione generica della scansione attraverso i valori di un contenitore. La sintassi per creare un vettore con un iteratore è la seguente:

modello<classe InputIterator>
vettore(InputIterator prima,InputIterator ultimo,costallocatore& =allocatore());

Questo costruisce un vettore per l'intervallo [first, last) usando l'allocatore specificato, che verrà discusso più avanti in questo articolo.

Distruggere un vettore

Per distruggere un vettore, è sufficiente consentirgli di uscire dall'ambito e la distruzione viene gestita automaticamente.

Capacità vettoriale

size_type capacità() const noeccezione

Il numero totale di elementi che il vettore può contenere senza richiedere la riallocazione viene restituito dalla funzione membro di capacità. Un segmento di codice per questo è il seguente:

vettore<galleggiante>vtr(4);
intnessuno=vtr.capacità();
costo<<nessuno<< ' ';

L'uscita è 4.

riserva(n)

Lo spazio di memoria non è sempre disponibile gratuitamente. Lo spazio extra può essere prenotato in anticipo. Considera il seguente segmento di codice:

vettore<galleggiante>vtr(4);
vtr.Riserva(6);
costo<<vtr.capacità() << ' ';

L'output è 6. Quindi, lo spazio extra riservato è 6 – 4 = 2 elementi. La funzione restituisce void.

size() const senza eccezione

Questo restituisce il numero di elementi nel vettore. Il codice seguente illustra questa funzione:

vettore<galleggiante>vtr(4);
galleggianteS=vtr.dimensione();
costo<<S<< ' ';

L'uscita è 4.

rimpicciolirsi per starci dentro()

Dopo aver dato capacità extra a un vettore con la funzione reserve(), il vettore può essere ridimensionato per adattarsi alla sua dimensione originale. Il codice seguente lo illustra:

vettore<galleggiante>vtr(4);
vtr.Riserva(6);
vtr.rimpicciolirsi per starci dentro();
intS=vtr.dimensione();
costo<<S<< ' ';

L'output è 4 e non 6. La funzione restituisce void.

ridimensiona (sz), ridimensiona (sz, c)

Questo ridimensiona il vettore. Se la nuova dimensione è inferiore alla vecchia dimensione, gli elementi verso la fine vengono cancellati. Se la nuova dimensione è più lunga, verso la fine viene aggiunto un valore predefinito. Per avere un particolare valore aggiunto, usa la funzione resize() con due argomenti. Il seguente segmento di codice illustra l'uso di queste due funzioni:

vettore<galleggiante>vtr1{1.1, 2.2, 3.3, 4.4};
vtr1.ridimensionare(2);
costo<< 'Nuova dimensione di vtr1: ' <<vtr1.dimensione() << ' ';
vettore<galleggiante>vtr2{1.1, 2.2};
vtr2.ridimensionare(4, 8.8);
costo<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' ';

L'output è il seguente:

Nuova dimensione di vtr1: 2
vtr2: 1.1 2.2 8.8 8.8

Le funzioni restituiscono void.

empty() const senza eccezione

Questa funzione restituisce 1 per vero se non ci sono elementi nel vettore e 0 per falso se il vettore è vuoto. Se un vettore ha 4 posizioni per un particolare tipo di dati, come float, senza alcun valore float, quel vettore non è vuoto. Il codice seguente lo illustra:

vettore<galleggiante>vtr;
costo<<vtr.vuoto() << ' ';
vettore<galleggiante>vt(4);
costo<<affinchévuoto() << ' ';

vettore<galleggiante>v(4,3.5);
costo<<v.vuoto() << ' ';

L'output è il seguente:

1
0
0

Accesso agli elementi vettoriali

Un vettore può essere sottoscritto (indicizzato) come un array. Il conteggio dell'indice inizia da zero.

vettoreNome[i]

L'operazione vectorName[i] restituisce un riferimento all'elemento in insindice del vettore. Il codice seguente restituisce 3.3 per il vettore sopra:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
galleggiantefl=vtr[2];
costo<<fl<< ' ';

vettoreNome[i] const

L'operazione vectorName[i] const viene eseguita al posto di vectorName[i] quando il vettore è un vettore costante. Questa operazione viene utilizzata nel codice seguente:

costvettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
galleggiantefl=vtr[2];
costo<<fl<< ' ';

L'espressione restituisce un riferimento costante alla inselemento del vettore.

Assegnazione di un valore con pedice

Un valore può essere assegnato a un vettore non costante, come segue:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vtr[2] = 8.8;
costo<<vtr[2] << ' ';

L'uscita è 8.8.

vettoreNome.at(i)

vectorName.at(i) è come vectorName[i], ma vectorName.at(i) è più affidabile. Il codice seguente mostra come dovrebbe essere usato questo vettore:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
galleggiantefl=vtr.a(2);
costo<<fl<< ' ';
a()è un membro del vettorefunzione.

vettoreNome.at(i) const

vectorName.at(i) const è come vectorName[i] const, ma vectorName.at(i) const è più affidabile. vectorName.at(i) const viene eseguito al posto di vectorName.at(i) quando il vettore è un vettore costante. Questo vettore è utilizzato nel codice seguente:

costvettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
galleggiantefl=vtr.a(2);
costo<<fl<< ' ';
a() costè un membro del vettorefunzione.

Assegnazione di un valore con la funzione at()

Un valore può essere assegnato a un vettore non costante con la funzione at(), come segue:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vtr.a(2) = 8.8;
costo<<vtr[2] << ' ';

L'uscita è 8.8.

Problema con il sub-script

Il problema con il sub-script (indicizzazione) è che se l'indice non è compreso nell'intervallo, è possibile che venga restituito zero o che venga emesso un errore in fase di esecuzione.

davanti()

Ciò restituisce un riferimento al primo elemento del vettore senza rimuovere l'elemento. L'output del codice seguente è 1.1.

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
galleggiantefl=vtr.davanti();
costo<<fl<< ' ';

L'elemento non viene rimosso dal vettore.

front() const

Quando la costruzione del vettore è preceduta da const, viene eseguita l'espressione front() const invece di front(). Questo è usato nel seguente codice:

costvettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
galleggiantefl=vtr.davanti();
costo<<fl<< ' ';

Viene restituito un riferimento costante. L'elemento non viene rimosso dal vettore.

Indietro()

Ciò restituisce un riferimento all'ultimo elemento del vettore senza rimuovere l'elemento. L'output del codice seguente è 4.4.

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
galleggiantefl=vtr.Indietro();
costo<<fl<< ' ';

indietro() const

Quando la costruzione del vettore è preceduta da const, viene eseguita l'espressione back() const invece di back(). Questo è usato nel seguente codice:

costvettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
galleggiantefl=vtr.Indietro();
costo<<fl<< ' ';

Viene restituito un riferimento costante. L'elemento non viene rimosso dal vettore.

Accesso ai dati vettoriali

data() noeccetto; data() const noeccetto;

Ciascuno di questi restituisce un puntatore tale che [data(), data() + size()) sia un intervallo valido.

Questo sarà trattato in maggior dettaglio più avanti nell'articolo.

Iteratori di ritorno e il vettore

Un iteratore è come un puntatore, ma ha più funzionalità di un puntatore.

begin() noeccetto

Restituisce un iteratore che punta al primo elemento del vettore, come nel seguente segmento di codice:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vettore<galleggiante> ::iteratoreiter=vtr.inizio();
costo<< *iter<< ' ';

L'uscita è 1.1. Si noti che la dichiarazione che riceve l'iteratore è stata dichiarata. L'iteratore viene dereferenziato in un'espressione di ritorno per ottenere il valore nello stesso modo in cui viene dereferenziato un puntatore.

begin() const noeccetto;

Restituisce un iteratore che punta al primo elemento del vettore. Quando la costruzione del vettore è preceduta da const, viene eseguita l'espressione begin() const invece di begin(). In questa condizione, l'elemento corrispondente nel vettore non può essere modificato. Questo è usato nel seguente codice:

costvettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vettore<galleggiante> ::const_iteratoriter=vtr.inizio();
costo<< *iter<< ' ';

L'uscita è 1.1. Nota che questa volta è stato utilizzato const_iterator invece del semplice iteratore per ricevere l'iteratore restituito.

end() senza eccezione

Restituisce un iteratore che punta immediatamente oltre l'ultimo elemento del vettore. Considera il seguente segmento di codice:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vettore<galleggiante> ::iteratoreiter=vtr.fine();
costo<< *iter<< ' ';

L'output è 0, che è privo di significato, poiché non esiste alcun elemento concreto oltre l'ultimo elemento.

end() const senza eccezione

Restituisce un iteratore che punta immediatamente oltre l'ultimo elemento del vettore. Quando la costruzione del vettore è preceduta da const, viene eseguita l'espressione end() const invece di end(). Considera il seguente segmento di codice:

costvettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vettore<galleggiante> ::const_iteratoriter=vtr.fine();
costo<< *iter<< ' ';

L'output è 0. Nota che questa volta è stato utilizzato const_iterator invece del semplice iteratore per ricevere l'iteratore restituito.

Iterazione inversa

È possibile avere un iteratore che itera dalla fine a poco prima del primo elemento.

rbegin() senza eccezione

Restituisce un iteratore che punta all'ultimo elemento del vettore, come nel seguente segmento di codice:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vettore<galleggiante> ::reverse_iteratorrIter=vtr.inizio();
costo<< *rIter<< ' ';

L'uscita è 4.4.

Si noti che la dichiarazione che riceve l'iteratore inverso è stata dichiarata. L'iteratore viene dereferenziato in un'espressione di ritorno per ottenere il valore nello stesso modo in cui viene dereferenziato un puntatore.

rbegin() const noeccetto;

Restituisce un iteratore che punta all'ultimo elemento del vettore. Quando la costruzione del vettore è preceduta da const, viene eseguita l'espressione rbegin() const invece di rbegin(). In questa condizione, l'elemento corrispondente nel vettore non può essere modificato. Questa funzione è utilizzata nel codice seguente:

costvettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vettore<galleggiante> ::const_reverse_iteratorrIter=vtr.inizio();
costo<< *rIter<< ' ';

L'uscita è 4.4.

Nota che questa volta è stato utilizzato const_reverse_iterator, invece del solo reverse_iterator, per ricevere l'iteratore restituito.

render() noeccetto

Restituisce un iteratore che punta appena prima del primo elemento del vettore. Considera il seguente segmento di codice:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vettore<galleggiante> ::reverse_iteratorrIter=vtr.fare();
costo<< *rIter<< ' ';

L'output è 0, che è privo di significato, poiché non c'è alcun elemento concreto appena prima del primo elemento.

render() const noeccetto

Restituisce un iteratore che punta appena prima del primo elemento del vettore. Quando la costruzione del vettore è preceduta da const, viene eseguita l'espressione rend() const invece di rend(). Considera il seguente segmento di codice:

costvettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vettore<galleggiante> ::const_reverse_iteratorrIter=vtr.fare();
costo<< *rIter<< ' ';

L'uscita è 0.

Nota che questa volta è stato utilizzato const_reverse_iterator, invece del solo reverse_iterator, per ricevere l'iteratore restituito.

Modificatori vettoriali

Un modificatore che modifica il vettore può prendere o restituire un iteratore.

a.emplace(p, argomenti)

Inserisce un oggetto di tipo T costruito con std::forward(args)… prima di p.

Per i dettagli – vedere più avanti

insert(iteratorPosition, value)

Inserisce una copia del valore nella posizione dell'iteratore del vettore. Restituisce l'iteratore (posizione) nel vettore in cui è stata posizionata la copia. Il codice seguente mostra dove è stato posizionato il valore:

vettore<int>vtr{10, venti, 30, 40};
vettore<int> ::iteratoreiter=vtr.inizio();
++iter;
++iter;
vtr.inserire(iter, 25);
costo<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3] << ' ';

L'uscita è: 20 25 30.

Nota che l'iteratore è stato avanzato (incrementato) proprio come un puntatore.

È anche possibile inserire un elenco di inizializzatori, come illustra il codice seguente:

vettore<int>vtr{10, venti, 30, 40};
vettore<int> ::iteratoreiter=vtr.inizio();
++iter;
++iter;
vtr.inserire(iter, {25, 28});

costo<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3]<< '' <<vtr[4] << ' ';

L'uscita è: 20 25 28 30.

cancellare (posizione)

Rimuove un elemento nella posizione puntata dall'iteratore, quindi restituisce la posizione dell'iteratore. Il codice seguente lo illustra:

vettore<int>vtr{10, venti, 30, 40};
vettore<int> ::iteratoreiter=vtr.inizio();
++iter;
++iter;
vtr.cancellare(iter);
costo<<vtr[0] << '' <<vtr[1] << '
'
<<vtr[2]<< ' ';

L'uscita è: 10 20 40

push_back(t), push_back(rv)

Utilizzato per aggiungere un singolo elemento alla fine del vettore. Usa push_back(t) come segue:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vtr.respingere(5,5);
galleggiantefl=vtr[4];
costo<<fl<< ' ';

L'uscita è 5,5.

respingere(rv): -vedi dopo.

pop_back()

Rimuove l'ultimo elemento senza restituirlo. La dimensione del vettore viene ridotta di 1. Il codice seguente lo illustra:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vtr.pop_back();
galleggianteS=vtr.dimensione();
costo<<S<< ' ';

L'uscita è 3.

a.scambio(b)

È possibile scambiare due vettori, come illustrato nel segmento di codice seguente:

vettore<galleggiante>vtr1{1.1, 2.2, 3.3, 4.4};
vettore<galleggiante>vtr2{10, venti};
vtr1.scambio(vtr2);
costo<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'
<<vtr1[2] <<''<<vtr1[3] << ' ';

costo<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' ';

L'uscita è:

vtr1: 10 venti 0 0
vtr2: 1.1 2.2 3.3 4.4

Notare che la lunghezza di un vettore viene aumentata, se necessario. Inoltre, i valori che non hanno avuto sostituzioni vengono sostituiti da un valore predefinito.

chiaro()

Rimuove tutti gli elementi dal vettore, come illustra il segmento di codice seguente:

vettore<galleggiante>vtr{1.1, 2.2, 3.3, 4.4};
vtr.chiaro();
costo<<vtr.dimensione() << ' ';

L'uscita è 0.

Operatori di uguaglianza e relazionali per i vettori

L'operatore ==

Restituisce 1 per vero se i due vettori hanno la stessa dimensione e gli elementi corrispondenti sono uguali; in caso contrario, restituisce 0 per false. Per esempio:

vettore<int>tu{1, 2, 3};
vettore<int>V{4, 5, 6};
bool blu=tu==V;
costo<<blu<< ' ';

L'uscita è 0.

L'operatore !=

Restituisce 1 per vero se i due vettori non hanno la stessa dimensione e/o gli elementi corrispondenti non sono uguali; in caso contrario, restituisce 0 per false. Per esempio:

vettore<int>tu{1, 2, 3};
vettore<int>V{4, 5, 6};
bool blu=tu! =V;
costo<<blu<< ' ';

L'uscita è 1.

Il

Restituisce 1 per vero se il primo vettore è il sottoinsieme iniziale del secondo vettore, con gli elementi delle due parti uguali uguali e nello stesso ordine. Se entrambi i vettori sono della stessa dimensione e si spostano da sinistra a destra e viene rilevato un elemento nel primo vettore che è minore dell'elemento corrispondente nel secondo vettore, verrà comunque restituito 1. In caso contrario, viene restituito 0 per false. Per esempio:

vettore<int>tu{3, 1, 1};
vettore<int>V{3, 2, 1};
bool blu=tu<V;
costo<<bl<< ' ';

L'uscita è 1.

Il > Operatore

Ritorna! (U

Il<= Operator

Resi U<= V, where U is the first vector and V is the second vector, according to the above definitions.

L'operatore >=

Ritorna! (U<= V), where U is the first vector and V is the second vector, according to the above definitions.

Conclusione

Un vettore è un esempio di contenitore di sequenza. Un vettore è una forma migliore dell'array ordinario ed è istanziato da una classe. I vettori hanno metodi classificati in: costruzione e assegnazione, capacità, accesso agli elementi, accesso ai dati, iteratori, modificatori e operatori numerici di overload.

Esistono altri contenitori di sequenza, chiamati list, forward_list e array. Se l'attività prevede inserimenti ed eliminazioni frequenti nel mezzo della sequenza, è necessario utilizzare un elenco o forward_list. Se l'attività prevede inserimenti ed eliminazioni frequenti all'inizio o alla fine della sequenza, è necessario utilizzare un deque. Quindi, i vettori dovrebbero essere usati solo quando questo tipo di operazioni non sono importanti.