Comment échanger les vecteurs en C++?

Si vtra devient 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm' et

vtrb devient 'a', 'b', 'c', 'd', 'e'

Ensuite, les deux vecteurs ont été échangés. Le fait que les vecteurs soient de longueurs différentes ne pose pas vraiment de problème. Pour que deux vecteurs soient échangés, ils doivent être du même type.

La classe vectorielle a une fonction membre pour échanger et un autre vecteur. La bibliothèque d'algorithmes a d'autres fonctions d'échange avec différents noms et à des fins modifiées. La principale différence entre la fonction Swap () du membre du vecteur et les fonctions de swap algorithme est que, bien que la fonction de membre échange son vecteur avec un autre vecteur, les fonctions d'échange de bibliothèque d'algorithme, chacune swap deux vecteurs indépendants.

La fonction du membre vectoriel, swap (), sera discutée dans cet article, et les fonctions de swap de bibliothèque d'algorithme seront également discutées. Tout le code vectoriel est effectué dans la fonction principale () pour cet article, sauf indication contraire.

Contenu de l'article

• Fonction de membre vectoriel swap ()
• Itération avec les itérateurs au lieu d'index
• Échange en échangeant des itérateurs
• Gamme
• Échange de plage avec tout le vecteur
• Conclusion

Fonction de membre vectoriel swap ()
échange de vide (vecteur et)

Dans le programme suivant, deux vecteurs sont déclarés et leur contenu total est échangé:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

vecteur vtra = 'a', 'b', 'c', 'd', 'e';
vecteur vtrb = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vtra.échange (vtrb);
pour (int i = 0; icouter << vtrA[i] << ";

couter << endl;
pour (int i = 0; icouter << vtrB[i] << ";

couter << endl;
retour 0;

La sortie est:

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

Le contenu total des deux vecteurs a été échangé. La bibliothèque vectorielle doit être incluse pour utiliser un vecteur en C ++, avec la directive: #include .

Dans le programme et dans la fonction principale (), le premier segment déclare les deux vecteurs. Le segment de code suivant d'une ligne qui est,

vtra.échange (vtrb);

échange les deux vecteurs. Il est clair que Swap (VTRB) est une fonction membre du vecteur, VTRA. Les deux segments de code à venir après afficher le contenu échangé.

Itération avec les itérateurs au lieu d'index

Un vecteur peut être itéré avec les itérateurs au lieu de l'index. Le programme suivant montre comment cela peut être fait pour le contenu du vecteur échangé:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

vecteur vtra = 'a', 'b', 'c', 'd', 'e';
vecteur vtrb = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vtra.échange (vtrb);
pour (vecteur:: iterator p = vtra.commencer(); p != VTRA.fin(); p ++)
couter << *p << ";

couter << endl;
pour (vecteur:: iterator q = vtrb.commencer(); q != vtrb.fin(); q ++)
couter << *q << ";

couter << endl;
retour 0;

La sortie est:

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

Notez la façon dont l'itérateur principal est initialisé dans chaque boucle pour. Notez la condition de ce qui est dans chaque boucle pour. L'itérateur principal dans chaque boucle pour être incrémenté comme l'index.

Échange en échangeant des itérateurs

La bibliothèque d'algorithmes a une fonction d'échange appelée iter_swap (). Cette fonction échange les deux principaux itérateurs de deux vecteurs indépendants. La syntaxe est:

void iter_swap (ForwardIterator1 a, ForwardIterator2 b)

Le programme suivant montre comment cette fonction algorithm-ite_swap () peut être appliquée:

#include>
#inclure
#inclure
Utilisation de Namespace Std;
int main()

vecteur vtra = 'a', 'b', 'c', 'd', 'e';
vecteur vtrb = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vecteur:: iterator u = vtra.commencer();
vecteur:: iterator v = vtrb.commencer();
échange (u, v);
pour (u = u; u != vtrb.fin(); u ++)
couter << *u << ";

couter << endl;
pour (v = v; v != VTRA.fin(); v ++)
couter << *v << ";

couter << endl;
retour 0;

La sortie est:

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

Notez que la bibliothèque d'algorithmes devait être incluse. Le segment de code en vedette de ce programme est:

vecteur:: iterator u = vtra.commencer();
vecteur:: iterator v = vtrb.commencer();
échange (u, v);

Pour la première de ces déclarations, U indique «A» du vecteur, VTRA. Pour la deuxième déclaration, V pointe vers «f» du vecteur, vtrb. La troisième déclaration échange le pointage. Avec lui, vous pointez maintenant le «f» de Vtrb et V pointe vers «A» de VTRA. u peut maintenant être habitué à itérer à travers les éléments de Vtrb, et v peut maintenant être utilisé pour itérer à travers les éléments de VTRA.

Gamme

Pour le vecteur,

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

la séquence,

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

est une gamme.

Les itérations de cette gamme peuvent être obtenues comme suit:

vecteur vtr = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vecteur:: iterator itb = vtr.commencer();
itb ++; itb ++;
vecteur:: iterator ite = vtr.fin();
ite--; ite--; ite--;
couter << *itB << " << *itE << endl;

La sortie est:

H k

L'expression, vtr.begin (), renvoie un itérateur qui pointe vers «f». L'expression, vtr.end (), renvoie un itérateur qui pointe juste après le dernier élément du vecteur. L'itérateur doit être incrémenté deux fois pour faire de l'itérateur qui pointe vers «F» pour pointer vers «H». Pour faire de l'itérateur qui pointe, juste au-delà du vecteur, pour pointer du «k», cet itérateur doit être diminué trois fois et pas deux fois. Lorsqu'il est décrémenté la première fois, il pointe vers le dernier élément, «M». Lorsqu'il a diminué la deuxième fois, il pointe vers l'élément précédent, «l». Et lorsqu'il a diminué la troisième fois, il pointe vers l'élément «K». * ITB renvoie la valeur de l'élément ITB. * ite renvoie la valeur de l'élément ite pointant pour la dernière fois.

La gamme, par itérateurs, est donc:

[itb, ite)

')' À la fin de la notation de la plage, cela signifie que, si la plage doit être installée dans un autre vecteur ou échangée avec un autre vecteur, la dernière valeur de la plage, représentée par ITE, ne sera pas impliquée. Autrement dit, seuls les éléments de l'ITB à celui juste avant, ITE sera copié ou échangé.

Échange de plage avec tout le vecteur

La bibliothèque d'algorithmes a une fonction pour échanger une plage dans un vecteur avec un autre vecteur entier. La syntaxe de la fonction est:

ForwardIterator2 Swap_Ranges (Forwiterator1 First1, ForwardIterator1 Last1, ForwardIterator2 First2)

First1 représente l'itérateur qui pointe vers le premier élément de la plage. Last1 représente l'itérateur qui pointe vers le dernier élément de la plage. Ce dernier élément n'est qu'un délimiteur; il ne sera pas impliqué dans l'échange. First2 pointe vers le premier élément du vecteur d'insertion. La fonction renvoie un itérateur qui pointe vers l'élément suivant, sans échanger le vecteur entier - voir le code suivant. Le programme suivant illustre cet échange avec la fonction swap_ranges ().

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

vecteur vtrb = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vecteur:: iterator itb = vtrb.commencer();
itb ++; itb ++;
vecteur:: iterator ite = vtrb.fin();
ite--; ite--; ite--;
vecteur vtra = 'a', 'b', 'c', 'd', 'e';
vecteur:: iterator itr = swap_ranges (itb, ite, vtra.commencer());
pour (int i = 0; icouter << vtrB[i] << ";
couter << endl;
couter << *itR << endl;
pour (int i = 0; icouter << vtrA[i] << ";
couter << endl;
retour 0;

La sortie est:

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

Notez que tout le vecteur n'a pas été échangé. Au lieu de cela, ce ne sont que les trois premières valeurs de tout le vecteur qui a été échangée, avec les troisième, quatrième et cinquième valeurs de Vtrb. Le sixième élément de VTRB n'était pas impliqué, et c'était prévu.

VTRA a 5 éléments, tandis que Vtrb a 8 éléments. Afin d'échanger vraiment le vecteur entier, VTRA de 5 éléments, la séquence de VTRB concernée, doit avoir 6 éléments (le sixième élément étant juste un délimiteur). Le programme suivant illustre ceci:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

vecteur vtrb = 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm';
vecteur:: iterator itb = vtrb.commencer();
itb ++; itb ++;
vecteur:: iterator ite = vtrb.fin();
ite--;
vecteur vtra = 'a', 'b', 'c', 'd', 'e';
vecteur:: iterator itr = swap_ranges (itb, ite, vtra.commencer());
pour (int i = 0; icouter << vtrB[i] << ";
couter << endl;
couter << *itR << endl;
pour (int i = 0; icouter << vtrA[i] << ";
couter << endl;
retour 0;

La sortie est:

F g a b c d e m
H I J K L

Cette fois, les 5 valeurs de VTRA ont été échangées avec les troisième, quatrième, cinquième, sixième et septième valeurs du VTRB. Ainsi, pour vraiment échanger un vecteur entier, le vecteur plus long doit avoir le nombre correspondant d'éléments (en séquence).

Conclusion

Échanger deux vecteurs signifie échanger le contenu d'un vecteur avec celui d'un autre. Pour que les vecteurs soient échangés, ils doivent être du même type. C ++ a une fonction membre pour le faire. Cela signifie que la fonction de membre Swap () d'un vecteur prend l'autre vecteur comme argument, puis échange le contenu. Si le programmeur veut plus de fonctionnalités d'échange, comme échanger les itérateurs ou échanger une plage dans un vecteur avec la liste totale d'un autre vecteur, il doit utiliser la bibliothèque d'algorithme.