Comment inverser un vecteur en C ++

Si un vecteur a des éléments dans la séquence, 'a', 'b', 'c', 'd', 'e' et il est reconfiguré tel que sa séquence devient, 'e', 'd', ' C ',' b ',' a ' puis le vecteur a été inversé. Malheureusement, une telle réversibilité directe n'est pas possible en C++. Cependant, un vecteur en C ++ peut être itéré de l'arrière, et c'est une réversibilité indirecte. Avec cela, il n'est pas nécessaire d'inverser le vecteur littéralement. Cet article explique comment itérer un vecteur en C ++ à l'arrière et modifier ses éléments.

Avant d'utiliser un vecteur en C ++, le programme doit commencer par,

#inclure
#inclure
Utilisation de Namespace Std;

avec la bibliothèque vectorielle incluse. Il est plus facile de comprendre l'itération inversée après avoir un résumé du transfert d'itération. L'itération de l'avenir est donc résumé avant que l'itération inverse ne soit expliquée.

Contenu de l'article

• Itération avancée
• Itération inversée
• Itérateur inverse constant
• Conclusion

Itération avancée

L'itération à terme traite de deux itérateurs. Un itérateur est un objet de pointeur élaboré avec des caractéristiques spéciales. Ici, les deux itérateurs d'intérêt sont retournés par la fonction du membre Begin () et la fonction de membre End (). La fonction de membre début () renvoie un itérateur qui pointe vers le premier élément du vecteur. La fonction de membre End () renvoie un itérateur qui pointe juste au-delà du dernier élément du vecteur.

Supposons que le nom du vecteur est VTR, puis l'instruction suivante renvoie un itérateur de début:

vecteur:: iterator p = vtr.commencer();

où p est le nom donné à l'itérateur de début. L'instruction suivante renvoie un itérateur de fin:

vecteur:: iterator q = vtr.fin();

où q est le nom donné à l'itérateur de fin, il peut être vu à partir des deux instructions ci-dessus que p et q sont du même type et peuvent même être échangées.

Tous les segments de code pour cet article sont écrits dans la fonction principale (). Le code suivant lit tous les éléments du vecteur, du début au dernier élément:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
pour (vecteur:: iterator p = vtr.commencer(); p != VTR.fin(); p ++)
couter << *p << ";

couter < vtr = 'A', 'B', 'C', 'D', 'E';
vecteur:: iterator q = vtr.fin();
pour (q = --q; q> = vtr.commencer(); q--)
couter << *q << ";

couter << endl;

La sortie est:

A b c d e

Le code dans les parenthèses de la boucle pour l'explication doit expliquer. P est un itérateur qui pointe d'abord vers le premier élément du vecteur. Bien qu'il ne pointe pas encore juste au-delà du vecteur, il est incrémenté de P ++ pour pointer vers chaque élément du vecteur. Lorsqu'il pointe vers un élément dans le vecteur, la valeur (caractère) de l'élément est obtenue avec * p dans le corps de la boucle pour. * est l'opérateur d'indirection.

Le code suivant lit et affiche les valeurs dans le vecteur du dernier élément au premier élément, en utilisant l'itérateur de fin:

vecteurvtr = 'a', 'b', 'c', 'd', 'e';
vecteur:: iterator q = vtr.fin();
pour (q = --q; q> = vtr.commencer(); q--)
couter << *q << ";

couter << endl;

La sortie est:

E d c b a

L'itérateur de fin pointe juste au-delà de la fin du vecteur, et ce n'est pas un élément. Donc, il doit être décrémenté avant de pouvoir pointer vers le dernier élément. De là, l'itération peut reculer.

La condition thire pour la boucle for ici est: «Si q est supérieur ou égal à l'itérateur de début». Il ne peut pas être «si q n'est pas égal à l'itérateur de début», car cela exclurait le premier élément.

C'est un moyen informel d'établir en arrière. C'est-à-dire qu'il s'agit d'un moyen informel d'inverser un vecteur indirectement.

Modification de la valeur d'un élément

Lorsque l'instanciation du vecteur n'est pas précédée de const (pour constante), la valeur de tout élément dans le vecteur peut être modifié. Le code suivant illustre ceci:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
vecteur:: iterator q = vtr.fin();
Q--; Q--; Q--;
* q = 'z';
vecteur:: iterator r = vtr.fin();
pour (r = - r; r> = vtr.commencer(); r--)
couter << *r << ";

couter << endl;

La sortie est:

E d z b a

L'itérateur final, Q est décrémenté trois fois avec «q-; Q-; q-; " pointer le «C».

Si l'instanciation vectorielle est précédée avec const, aucune valeur d'élément ne peut être modifiée. Dans ce cas, l'itérateur en avant constant doit être retourné pour la fin ou le début de l'itérateur. Le code suivant ne se compile pas car une tentative est faite pour modifier la valeur de «C»:

vctor de constance vtr = 'a', 'b', 'c', 'd', 'e';
vecteur:: const_iterator q = vtr.fin();
Q--; Q--; Q--;
* q = 'z';

Itération inversée

L'itération inversée a deux itérateurs principaux. Ces itérateurs sont renvoyés par les fonctions des membres, RBEGIN () et Rend (). Rend () renvoie un itérateur qui pointe juste devant le premier élément du vecteur. rbegin () renvoie un itérateur qui pointe vers le dernier élément du vecteur. Le code suivant lit et affiche les éléments du vecteur, du premier au dernier, dans la direction avant:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
vecteur>: reverse_iterator p = vtr.déchirer();
pour (p = --p; p> = vtr.rbegin (); P--)
couter << *p << ";

couter << endl;

La sortie est:

A b c d e

L'itérateur inversé est utilisé. Puisque Rend () renvoie un itérateur qui pointe juste devant le premier élément, qui n'est pas un élément, il doit être incrémenté pour pointer vers le premier élément. Puisque nous avons affaire à l'itérateur inversé, l'opérateur d'incrément ici est - et non ++. De plus, dans la condition que,> = est utilisé à la place de <= .

Le code suivant lit et affiche les valeurs du vecteur, du dernier élément au premier élément, en utilisant l'itérateur de rBegin ():

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
pour (vecteur:: reverse_iterator q = vtr.rbegin (); q <= vtr.rend(); q++)
couter << *q << ";

couter << endl;

La sortie est:

E d c b a

La fonction membre rbegin () renvoie un itérateur qui pointe vers le dernier élément du vecteur. L'itérateur retourné est un reverse_iterator. Rend () renvoie un itérateur qui pointe juste avant le premier élément. Notez que la condition While pour la boucle for mais =, puisque nous avons affaire à un itérateur inversé. La diminution de cet itérateur est ++ et non -.

Modification de la valeur d'un élément

Lorsque l'instanciation du vecteur n'est pas précédée de const (pour constante), la valeur de tout élément dans le vecteur peut être modifiée avec le revers. Le code suivant l'illustre, avec le revers_iterator:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
vecteur:: reverse_iterator q = vtr.rbegin ();
q ++; q ++;
* q = 'x';
pour (vecteur:: reverse_iterator r = vtr.rbegin (); r <= vtr.rend(); r++)
couter << *r << ";

couter << endl;

La sortie est:

E d x b a

L'itérateur RBEGIN (), Q est diminué deux fois avec «Q ++; q ++; " Pour pointer du «C», car il pointe initialement le dernier élément.

Si l'instanciation vectorielle est précédée avec const, aucune valeur d'élément ne peut être modifiée, avec un itérateur, que ce soit le reverse_iterator iterator (ou en avant). Dans ce cas, l'itérateur inverse constant doit être renvoyé pour la fonction RBEGIN () ou Rend (). Le code suivant ne se compile pas car une tentative est faite pour modifier la valeur de «C»:

vctor de constance vtr = 'a', 'b', 'c', 'd', 'e';
vecteur:: const_reverse_iterator q = vtr.rbegin ();
q ++; q ++;
* q = 'x';

Itérateur inverse constant

Crbegin () se comporte comme rbegin (), mais renvoie un const_reverse_iterator, si l'instanciation du vecteur a commencé ou non avec const. Cela signifie que la valeur de l'itérateur renvoyé ne peut pas être modifiée. Crend () se comporte comme Rend (), mais renvoie un const_reverse_iterator, si l'instanciation du vecteur a été commencé avec const avec const avec const. Cela signifie que la valeur de l'itérateur renvoyé ne peut pas être modifiée.

Le code suivant affiche toutes les valeurs du vecteur, en utilisant const_reverse_iterator, à partir du dernier élément:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
pour (vecteur:: const_reverse_iterator q = vtr.crbegin (); q <= vtr.crend(); q++)
couter << *q << ";

couter << endl;

La sortie est:

E d c b a

Le code suivant ne se compilera pas car nous traitons ici d'un itérateur inverse constant. L'instanciation du vecteur n'est pas précédée par const.

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
pour (vecteur:: reverse_iterator q = vtr.rbegin (); q <= vtr.rend(); q++)
couter << *q << ";

couter << endl;

Conclusion

Un vecteur ne peut pas être inversé littéralement. Cependant, il peut être itéré de dos à l'avant pour avoir un résultat similaire. Avec l'itération vers l'avant, les fonctions des membres, begin () et end () sont impliquées. Dans le cas de l'itération inverse, les fonctions des membres, Rbegin () et Rend () sont impliquées. Dans ce cas, l'itérateur impliqué est Reverse_iterator et non un itérateur. Toujours dans ce cas, ++ est - et> = est <= . There is also const_reverse_iterator, for crbegin() and crend() member functions.