Funzioni del membro vettoriale C ++ più utili

Le funzioni del membro vettoriale C ++ possono essere inserite nelle seguenti categorie: costruzione, capacità, iteratori, accesso agli elementi e modificatori. Ognuna di queste categorie ha molte funzioni. Tutte queste funzioni non sono utilizzate in molte applicazioni. Questo articolo spiega il più utile di queste funzioni. Con l'eccezione della categoria modificatori, non più di tre funzioni per ciascuna categoria sono spiegate in questo articolo. La categoria dei modificatori può essere suddivisa in più categorie secondarie. In ciascuna di queste seconde categorie, non verranno spiegate più di tre funzioni. Se devono essere spiegati più di tre funzioni per una determinata categoria, allora verranno insegnati tramite illustrazione.

Un programma per utilizzare il vettore C ++ dovrebbe iniziare con,

#includere
#includere

Contenuto dell'articolo

• Costruzione/distruzione
• Capacità
• Accesso iteratore e vettoriale
• Accesso agli elementi
• Spingi indietro e fai un salto
• Inserimento
• Assegnazione di elementi (sostituzioni)
• Cancellare
• Chiaro
• Scambiarsi
• Conclusione

Costruzione/distruzione

I seguenti segmenti di codice mostrano diversi modi per creare lo stesso vettore:

vettore VTR;
VTR.push_back (5.5);
VTR.push_back (6.6);
VTR.push_back (7.7);
VTR.push_back (8.8);
VTR.push_back (9.9);
vettore VTR (3); // con il numero iniziale di elementi
VTR [0] = 5.5;
VTR [1] = 6.6;
VTR [2] = 7.7;
vettore VTR (5, 0.0); //NO. Elementi: 5; ogni valore: 0.0
vettore VTR 5.5, 6.6, 7.7, 8.8, 9.9; // inizializzazione
vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9; // Costruire e copiare
vettore VTR;
vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore VTR1 5.5, 6.6, 7.7, 8.8, 9.9;
vettore VTR2 (VTR1);
const vector vtr = 5.5, 6.6, 7.7, 8.8, 9.9;

UN const vector è un vettore i cui elementi non possono essere cambiati. I valori sono di sola lettura.

Distruzione

Per distruggere un vettore, lascialo andare fuori dalla portata.

Capacità

dimensione () const noexcept

Il numero di elementi in un vettore viene restituito da questa funzione membro. Con il seguente segmento di codice, l'output è 5:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
float sz = vtr.misurare();
cout << sz << '\n';
vuoto () const noexcept

Questo metodo restituisce vero (1) se il vettore non ha elemento e falso (0) se il vettore ha almeno un elemento. Con il seguente codice, l'output è 1 (per vero):

vettore vtr = ;
bool bl = vtr.vuoto();
cout << bl << '\n';

Accesso iteratore e vettoriale

Un iteratore è un puntatore elaborato. Quando il vettore, VTR è stato creato, VTR.inizio() restituirebbe un iteratore, indicando il primo elemento dell'elenco. Può quindi essere incrementato per accedere agli elementi dopo il primo, di conseguenza.

Quando il vettore, VTR è stato creato, VTR.FINE() restituirebbe un iteratore, indicando subito l'ultimo elemento dell'elenco. Può quindi essere decrementato per accedere all'ultimo elemento e agli elementi prima dell'ultimo, di conseguenza. Il seguente programma illustra questo:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb = VTR.inizio();
iTerb ++;
vettore:: iteratore itere = vtr.FINE();
itere--;
cout << *iterB << ", " << *iterE << " << endl;
*iTerb = 66.66; *itere = 99.99;
cout << *iterB << ", " << *iterE << " << endl;
restituzione 0;

L'output è:

6.6, 9.9
66.66, 99.99

I valori di due elementi sono stati accessibili, letti e modificati da due iteratori.

Accesso agli elementi

a (i)

Questo è simile a VTR [i], ed è meglio. Può essere usato per leggere o modificare il valore di un elemento. Il conteggio dell'indice inizia da zero. Il lettore può testare il seguente programma:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
cout << vtr[1] << ", " << vtr[4] << " << endl;
VTR [1] = 66.66; VTR [4] = 99.99;
cout << vtr[1] << ", " << vtr[4] << " << endl;
restituzione 0;

L'output è:

6.6, 9.9
66.66, 99.99

I valori di due elementi sono stati accessibili, letti e modificati attraverso il riferimento.

Restituire il primo valore

Il seguente codice restituisce (copie fuori) il primo elemento:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Float Val = VTR.davanti();
cout << val << endl;

L'output è, 5.5. La funzione membro utilizzata qui è: front ().

Restituendo l'ultimo valore

Il seguente codice restituisce (copie fuori) l'ultimo elemento:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
Float Val = VTR.Indietro();
cout << val << endl;

L'output è, 9.9. La funzione membro utilizzata qui è: back ().

Spingi indietro e fai un salto

respingere()

Un elemento può essere aggiunto sul retro del vettore. Il valore può essere letterale o essere rappresentato dall'identificatore. Il seguente codice illustra questo:

float flt = 10.10;
vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
VTR.push_back (flt);
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

Il nuovo elenco è:

5.5, 6.6, 7.7, 8.8, 9.9, 10.1

pop_back ()

L'ultimo elemento può essere rimosso dal vettore. Il seguente codice illustra questo:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
VTR.pop_back ();
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

Il nuovo elenco è:

5.5, 6.6, 7.7, 8.8

Nota: Il vettore non ha le funzioni del membro push_front () e pop_front ().

Inserimento

Inserti davanti all'elemento puntato, dall'iteratore.

inserire (p, e)

Questo inserisce un elemento prima che l'elemento puntato dall'iteratore, p. e può essere un letterale o un identificatore. Illustrazione:

float flt = 7.0;
vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb = VTR.inizio();
iTerb ++; iTerb ++;
VTR.Inserisci (iTerb, flt);
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

Il nuovo elenco è:

5.5, 6.6, 7, 7.7, 8.8, 9.9

Questa funzione di inserimento restituisce un iteratore (non codificato) che indica l'elemento inserito.

Inserisci (P, IL)

Un elenco può essere inserito di fronte all'elemento puntato dall'iteratore. Illustrazione:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb = VTR.inizio();
iTerb = iTerb + 2;
VTR.insert (iTerb, 7.1, 7.2, 7.3);
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

Il nuovo elenco è:

5.5, 6.6, 7.1, 7.2, 7.3, 7.7, 8.8, 9.9

Questa funzione di inserimento restituisce un iteratore (non codificato) che indica il primo elemento inserito.

Inserisci (P, N, T)

Inserisce lo stesso valore t, n volte, davanti all'elemento puntato da p. Illustrazione:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb = VTR.inizio();
iTerb = iTerb + 2;
VTR.Inserisci (iTerb, 3, 7.1);
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

Il nuovo elenco è:

5.5, 6.6, 7.1, 7.1, 7.1, 7.7, 8.8, 9.9

Questa funzione di inserimento restituisce un iteratore (non codificato) che indica il primo elemento inserito.

inserisci (p, i, j)

Un intervallo può essere copiato da un altro vettore e inserito nel vettore di interesse. Il seguente codice illustra questo:

vettore vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
vettore:: iterator iTerb1 = vtr1.inizio();
iTerb1 = iTerb1 + 1;
vettore:: iteratore itere1 = vtr1.FINE();
itere1 = itere1 - 2;
vettore vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb2 = vtr2.inizio();
iTerB2 = iTerb2 + 2;
VTR2.inserire (iTerb2, iTerb1, itere1);
per (int i = 0; icout << vtr2[i] << ", ";
cout << endl;

L'elenco originale per VTR2 è:

5.5, 6.6, 7.7, 8.8, 9.9

Il nuovo elenco per VTR2 è:

5.5, 6.6, 7.2, 7.3, 7.7, 8.8, 9.9

L'intervallo identificato per essere copiato è [7.2, 7.3, 7.4), indicato come [i, j), che significa l'ultimo valore, 7.4 non è incluso.

Questa funzione di inserimento restituisce un iteratore (non codificato) che indica il primo elemento inserito.

Assegnazione di elementi (sostituzioni)

Assegnare ad elementi significa sostituire gli elementi con copie. Tutte le funzioni dei membri dell'assegnazione, restituire vuoto.

Assegna (IL)

Un elenco può sostituire tutti gli elementi nel vettore in questione. L'elenco può essere più lungo o più breve. Illustrazione per breve elenco:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb = VTR.inizio();
iTerb = iTerb + 2;
VTR.Assegna (55.55, 66.66, 77.77);
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

Il nuovo elenco è:

55.55, 66.66, 77.77

Illustrazione per un elenco più lungo:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb = VTR.inizio();
iTerb = iTerb + 2;
VTR.Assegna (55.55, 66.66, 77.77, 88.88, 99.99, 1010.1111);
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

Il nuovo elenco è:

55.55, 66.66, 77.77, 88.88, 99.99, 1010.11

Assegna (n, t)

Lo stesso valore, ripetuto più volte, può sostituire tutti gli elementi del vettore in questione. Il nuovo elenco può essere più lungo o più breve. Illustrazione per breve elenco:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb = VTR.inizio();
iTerb = iTerb + 2;
VTR.Assegna (2, 77.77);
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

Il nuovo elenco è:

77.77, 77.77

Assegna (i, j)

Un intervallo può essere copiato da un altro vettore ed essere utilizzato per sostituire tutto il contenuto del vettore di interesse. Il seguente codice illustra questo:

vettore vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
vettore:: iterator iTerb1 = vtr1.inizio();
iTerb1 = iTerb1 + 1;
vettore:: iteratore itere1 = vtr1.FINE();
itere1 = itere1 - 2;
vettore vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb2 = vtr2.inizio();
iTerB2 = iTerb2 + 2;
VTR2.assegnare (iTerb1, itere1);
per (int i = 0; icout << vtr2[i] << ", ";
cout << endl;

L'elenco originale per VTR2 è:

5.5, 6.6, 7.7, 8.8, 9.9

Il nuovo elenco per VTR2 è:

7.2, 7.3

L'intervallo identificato per essere copiato è [7.2, 7.3, 7.4), indicato come [i, j), che significa l'ultimo valore, 7.4 non è incluso.

Cancellare

Usa iteratore.

Cancella (Q)

Rimuove l'elemento puntato da Q, accorciando la lunghezza del vettore. Restituisce l'iteratore che punta all'elemento successivo, dopo la rimozione. Esempio:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb = VTR.inizio();
iTerb = iTerb + 2;
vettore:: iterator ITR = VTR.cancella (iterb);
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;
cout << *itR << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

L'output è:

5.5, 6.6, 8.8, 9.9,
8.8

Cancella (Q1, Q2)

Rimuove una serie di elementi che iniziano da quello indicato dall'iteratore Q1, a quello indicato da Q2, ma escludendo quello di Q2 - cioè rimuove [Q1, Q2). Restituisce l'iteratore che punta all'elemento successivo, dopo la rimozione della gamma. Illustrazione:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vettore:: iterator iTerb = VTR.inizio();
iTerb = iTerb + 2;
vettore:: iteratore itere = vtr.FINE();
itere = itere - 1;
vettore:: iterator ITR = VTR.cancella (iterb, itere);
per (int i = 0; icout << vtr[i] << ", ";
cout << endl;
cout << *itR << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

L'output è:

5.5, 6.6, 9.9,
9.9

Chiaro

chiaro()

Restituisce vuoto. Tutti gli elementi in un vettore possono essere rimossi, riducendo la lunghezza del vettore a zero. Questo è come:

vettore vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
VTR.chiaro();
cout << vtr.size() << endl;

L'elenco originale è:

5.5, 6.6, 7.7, 8.8, 9.9

L'output è:

0

Scambiarsi

X.scambia (y)

Gli elementi di due diversi vettori possono essere scambiati, indipendenti dalle loro diverse lunghezze. Illustrazione:

vettore vtr1 = 1.1, 2.2, 3.3, 4.4;
vettore vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
VTR2.swap (vtr1);
cout << "New vtr1: ";
per (int i = 0; icout << vtr1[i] << ", ";
cout << endl;
cout << "New vtr2: ";
per (int i = 0; icout << vtr2[i] << ", ";
cout << endl;

L'output è:

Nuovo VTR1: 5.5, 6.6, 7.7, 8.8, 9.9,
Nuovo VTR2: 1.1, 2.2, 3.3, 4.4,

Conclusione

Il vettore C ++ ha molte funzioni dei membri. Queste funzioni possono essere classificate nelle seguenti sottocategorie: costruzione/distruzione, capacità, iteratore e accesso vettoriale, accesso agli elementi, spinta indietro e pop, inserendo, assegnazione di elementi (sostituti), cancella, chiaro e scambiati. Le funzioni più utili in ciascuna di queste sottocategorie sono state spiegate sopra.