Come si scambiano i vettori in C++?

Se vtra diventa 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm' e

VTRB diventa 'a', 'b', 'c', 'd', 'e'

Quindi entrambi i vettori sono stati scambiati. Il fatto che i vettori abbiano diverse lunghezze non pone davvero un problema. Affinché due vettori vengano scambiati, devono essere dello stesso tipo.

La classe Vector ha una funzione membro per scambiare se stesso e un altro vettore. La libreria dell'algoritmo ha altre funzioni di swap con nomi diversi e per scopi modificati. La differenza principale tra la funzione Swap () Swap () e le funzioni di swap dell'algoritmo è che, mentre la funzione membro scambia il suo vettore con un altro vettore, le funzioni di swap della libreria dell'algoritmo, ciascuno scambio di due vettori indipendenti.

In questo articolo sarà discussa la funzione membro vettoriale, Swap (). Tutto il codice vettoriale viene svolto nella funzione principale () per questo articolo se non diversamente indicato.

Contenuto dell'articolo

• Funzione Swap () membro vettoriale ()
• Iterare con iteratori anziché indici
• Scambiare scambiando iteratori
• Allineare
• Scambiare gamma con l'intero vettore
• Conclusione

Funzione Swap () membro vettoriale ()
vuoto scambio (vettoriale e)

Nel seguente programma, vengono dichiarati due vettori e il loro contenuto totale viene scambiato:

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

vettore vtra = 'a', 'b', 'c', 'd', 'e';
vettore vtrb = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vtra.Swap (VTRB);
per (int i = 0; icout << vtrA[i] << ";

cout << endl;
per (int i = 0; icout << vtrB[i] << ";

cout << endl;
restituzione 0;

L'output è:

F g h i j k l m
A b c d e

Il contenuto totale di entrambi i vettori è stato scambiato. La libreria vettoriale deve essere inclusa per utilizzare un vettore in C ++, con la direttiva: #Include .

Nel programma e nella funzione principale (), il primo segmento dichiara i due vettori. Il prossimo segmento di codice di una riga che è,

vtra.Swap (VTRB);

scambia entrambi i vettori. È chiaro che lo swap (VTRB) è una funzione membro del vettore, VTRA. I due segmenti di codice in arrivo dopo la visualizzazione del contenuto scambiato.

Iterare con iteratori anziché indici

Un vettore può essere iterato con iteratori anziché con l'indice. Il seguente programma mostra come questo può essere fatto per il contenuto del vettore scambiato:

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

vettore vtra = 'a', 'b', 'c', 'd', 'e';
vettore vtrb = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vtra.Swap (VTRB);
per (vettore:: iterator p = vtra.inizio(); P != vtra.FINE(); p ++)
cout << *p << ";

cout << endl;
per (vettore:: iteratore Q = VTRB.inizio(); Q != VTRB.FINE(); Q ++)
cout << *q << ";

cout << endl;
restituzione 0;

L'output è:

F g h i j k l m
A b c d e

Nota nel modo in cui l'iteratore principale viene inizializzato in ciascun circuito. Nota la condizione while in ciascun per loop. L'iteratore principale in ciascun loop è incrementato proprio come l'indice.

Scambiare scambiando iteratori

La libreria dell'algoritmo ha una funzione di swap chiamata iter_swap (). Questa funzione scambia i due principali iteratori di due vettori indipendenti. La sintassi è:

void iter_swap (forwardterator1 a, forwardterator2 b)

Il seguente programma mostra come applicare questo algoritmo-iter_swap ():

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

vettore vtra = 'a', 'b', 'c', 'd', 'e';
vettore vtrb = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vettore:: iterator u = vtra.inizio();
vettore:: iterator v = VTRB.inizio();
Swap (u, v);
per (u = u; u != VTRB.FINE(); u ++)
cout << *u << ";

cout << endl;
per (v = v; v != vtra.FINE(); V ++)
cout << *v << ";

cout << endl;
restituzione 0;

L'output è:

F g h i j k l m
A b c d e

Si noti che doveva essere inclusa la libreria dell'algoritmo. Il segmento di codice in primo piano per questo programma è:

vettore:: iterator u = vtra.inizio();
vettore:: iterator v = VTRB.inizio();
Swap (u, v);

Per la prima di queste affermazioni, U indica "A" del vettore, VTA. Per la seconda affermazione, V indica 'f' del vettore, VTRB. La terza affermazione scambia il puntamento. Con esso, ora indica "f" di VTRB e V punta a "a" di vtra. ora puoi essere usato per iterare attraverso gli elementi di VTRB e V ora può essere usato per iterare attraverso gli elementi di VTRA.

Allineare

Per il vettore,

'F', 'g', 'h', 'i', 'j', 'k', 'l', 'm'

la sequenza,

'H', 'I', 'J', 'K'

è un intervallo.

Le iterazioni per questa gamma possono essere ottenute come segue:

vettore vtr = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vettore:: iterator ITB = VTR.inizio();
ITB ++; ITB ++;
vettore:: iterator ite = vtr.FINE();
ite--; ite--; ite--;
cout << *itB << " << *itE << endl;

L'output è:

HK

L'espressione, VTR.inizio (), restituisce un iteratore che indica "f". L'espressione, VTR.end (), restituisce un iteratore che punta subito dopo l'ultimo elemento del vettore. L'iteratore deve essere incrementato due volte per rendere l'iteratore che indica "F" per indicare "H". Per rendere l'iteratore che punti, appena oltre il vettore, per indicare "k", quell'iteratore deve essere decrementato tre volte e non due volte. Quando viene decrementato la prima volta, indica l'ultimo elemento, 'M'. Quando diminuisce la seconda volta, indica prima l'elemento, 'L'. E quando decrementato la terza volta, indica l'elemento, 'K'. *ITB restituisce il valore dell'elemento ITB era l'ultima volta. *Ite restituisce il valore dell'elemento Ite è stato l'ultima volta che ha indicato.

Quindi la gamma, da parte di iteratori, è:

[ITB, ite)

')' alla fine della notazione dell'intervallo significa che, se l'intervallo deve essere inserito in un altro vettore o scambiare con un altro vettore, l'ultimo valore dell'intervallo, rappresentato da ITE, non sarà coinvolto. Cioè, solo elementi da ITB a quello poco prima, Ite verrà copiato o scambiato.

Scambiare gamma con l'intero vettore

La libreria dell'algoritmo ha una funzione per scambiare un intervallo in un vettore con un altro intero vettore. La sintassi per la funzione è:

Displatore di swap_ranges (forwardterator1, wawneterator1, wawneterator2 First2)

First1 rappresenta l'iteratore che indica il primo elemento dell'intervallo. Last1 rappresenta l'iteratore che indica l'ultimo elemento dell'intervallo. Quest'ultimo elemento è solo un delimitatore; non sarà coinvolto nello scambio. Primo 2 punti al primo elemento del vettore di inserimento. La funzione restituisce un iteratore che indica l'elemento successivo, non scambiando l'intero vettore - vedere il codice seguente. Il seguente programma illustra questo scambio con la funzione swap_ranges ().

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

vettore vtrb = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vettore:: iterator ITB = VTRB.inizio();
ITB ++; ITB ++;
vettore:: iterator ite = VTRB.FINE();
ite--; ite--; ite--;
vettore vtra = 'a', 'b', 'c', 'd', 'e';
vettore:: iterator itr = swap_ranges (ITB, ite, vtra.inizio());
per (int i = 0; icout << vtrB[i] << ";
cout << endl;
cout << *itR << endl;
per (int i = 0; icout << vtrA[i] << ";
cout << endl;
restituzione 0;

L'output è:

F g a b c k l m
D
H i j d e

Si noti che l'intero vettore non è stato scambiato. Invece, sono solo i primi tre valori dell'intero vettore che è stato scambiato, con il terzo, il quarto e il quinto valori di VTRB. Il sesto elemento di VTRB non era coinvolto, e questo era previsto.

VTRA ha 5 elementi, mentre VTR ha 8 elementi. Per scambiare veramente l'intero vettore, VTRA di 5 elementi, la sequenza in VTRB interessata, deve avere 6 elementi (con il sesto elemento solo un delimitatore). Il seguente programma illustra questo:

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

vettore vtrb = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vettore:: iterator ITB = VTRB.inizio();
ITB ++; ITB ++;
vettore:: iterator ite = VTRB.FINE();
ite--;
vettore vtra = 'a', 'b', 'c', 'd', 'e';
vettore:: iterator itr = swap_ranges (ITB, ite, vtra.inizio());
per (int i = 0; icout << vtrB[i] << ";
cout << endl;
cout << *itR << endl;
per (int i = 0; icout << vtrA[i] << ";
cout << endl;
restituzione 0;

L'output è:

F g a b c d e m
H i j k l

Questa volta, tutti e 5 i valori di VTRA sono stati scambiati con il terzo, il quarto, il quinto, il sesto e il settimo valori del VTR. Quindi, per scambiare veramente un intero vettore, il vettore più lungo dovrebbe avere il numero corrispondente di elementi (in sequenza).

Conclusione

Scambiare due vettori significa scambiare il contenuto di un vettore con quello di un altro. Affinché i vettori vengano scambiati, devono essere dello stesso tipo. C ++ ha una funzione membro per farlo. Ciò significa che la funzione di scambio () di un vettore prende l'altro vettore come argomento, quindi scambia il contenuto. Se il programmatore desidera più funzionalità di scambio, come scambiare gli iteratori o scambiare un intervallo in un vettore con l'elenco totale di un altro vettore, deve utilizzare la libreria dell'algoritmo.