Boucle à travers un vecteur en C ++

Nathan Blanc

Transférer à travers un vecteur signifie accéder à tous les éléments du vecteur du début à la fin, ou de la fin au début. Les éléments peuvent être accessibles pour la lecture ou l'écriture (modification de la valeur) ou les deux.

En C ++, le vecteur peut être bouclé en utilisant la boucle pour l'indice (index) classique avec l'indice (index) dans les crochets. Il peut être bouclé en utilisant la gamme basée sur la mise en place. Il peut être bouclé via à l'aide de la fonction for_each () incluse dans la bibliothèque d'algorithmes.

Contenu de l'article

- Boucle en utilisant la boucle classique

- Boucle en utilisant la gamme basée sur la mise en place

- Boucle en utilisant la fonction for_each ()

- Conclusion

Boucle en utilisant la boucle classique

Indice

Considérez le segment de code suivant:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
char ch = vtr [2];
couter << ch << endl;

La sortie est «C». Dans la deuxième déclaration, après le nom du vecteur, VTR, se trouve les crochets. À l'intérieur des crochets se trouve l'index, qui est également l'indice vectoriel. Le comptage d'index commence à partir de zéro. L'index dans le code est 2, qui renvoie le troisième élément du vecteur.

Boucle avec indice

Pour boucler avec l'indice ou itérateur, la boucle doit être utilisée. La boucle de boucle ou de bricolage peut également être utilisée, mais la boucle est la plus pratique. La syntaxe d'une boucle pour:

pour (début_state; while_condition; suivant / précédent)
// déclarations

Boucle en boucle

Le programme suivant utilise une boucle pour boucle pour faire bouger, un vecteur de caractères (chars), par indice:

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

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
pour (int i = 0; ichar ch = vtr [i];
couter << ch << ";

couter << endl;
retour 0;

La sortie est:

A b c d e

La bibliothèque vectorielle doit être incluse pour que la classe vectorielle soit utilisée. Dans la fonction principale C ++, après la création du vecteur est la boucle pour. Cette boucle peut être résumé comme suit: Lisez chaque élément du vecteur commençant par l'index, 0; Et tandis que la fin du vecteur n'est pas encore atteinte, augmentez l'indice de 1 pour lire l'élément suivant.

Les parenthèses de la boucle ont la logique de ce qu'il faut lire ensuite, tandis que le bloc de la boucle pour la lecture et l'impression au terminal (console).

Boucler vers l'avant et sauter

Dans la boucle ci-dessus, la prochaine déclaration entre parenthèses est i++. C'est la même chose que:

i = i + 1

Avec cela, les éléments sont lus l'un après l'autre dans la direction avant. Afin de lire tous les autres éléments (sautant un élément à chaque fois), le prochain argument entre parenthèses doit être

i = i + 2; ce qui est le même que i + = 2;

Le code suivant lit tous les autres personnages:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
pour (int i = 0; ichar ch = vtr [i];
couter << ch << ";

couter << endl;

La sortie est:

AS
sautant «B» et «D».

Boucle en arrière

Le code suivant utilise une boucle pour boucler vers l'arrière, un vecteur de caractères (chars):

int main()

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
pour (int i = vtr.size () - 1; jechar ch = vtr [i];
couter << ch << ";

couter << endl;
retour 0;

La sortie est:

E d c b a

La boucle commence à partir de l'indice le plus élevé (4), qui est donné par:

vtr.size () - 1

Dans ce cas, la fonction membre du vecteur, size () renvoie 5. 1 doit être soustrait pour obtenir l'indice le plus élevé de 4 (le comptage d'index commence à partir de 0). Pour boucler en arrière, la déclaration précédente entre parenthèses est maintenant «i-».

Boucle en arrière et sauter

Dans la boucle ci-dessus, l'instruction précédente est i-. C'est la même chose que:

i = i - 1

Avec cela, les éléments sont lus l'un après l'autre dans le sens inverse. Afin de lire tous les autres éléments (sautant un élément à chaque fois) à l'envers, la déclaration précédente doit être

i = i - 2; qui est le même que i- = 2;

Le code suivant indique tous les autres personnages, en arrière:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
pour (int i = vtr.size () - 1; jechar ch = vtr [i];
couter << ch << ";

couter << endl;

La sortie est:

E c a

sautant 'd' et 'b'.

Boucle à l'aide d'une classe d'itérateur

Un vecteur peut être bouclé avec un itérateur. Il y a six classes d'itérateur vectorielles. Seuls deux sont utilisés ici. Les noms des deux sont: Iterator et Reverse_iterator. Dans les illustrations ici, la boucle forte est toujours utilisée comme boucle.

Un itérateur est un pointeur élaboré. Pour chaque itérateur, il y a une classe à partir de laquelle les objets peuvent être instanciés. L'objet instancié est l'itérateur.

Boucle en boucle

Le programme suivant utilise une boucle pour boucle pour faire bouger, un vecteur de caractères (chars), par itérateur:

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

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
vecteur:: iterator iter = vtr.commencer();
pour (iter = iter; iterchar ch = * iter;
couter << ch << ";

couter << endl;
retour 0;

La sortie est:

A b c d e

Observez comment l'objet Iterator, Iter a été déclaré. Le vecteur a la fonction membre commence (). Cela renvoie un itérateur qui pointe vers le premier élément du vecteur. Il y a une autre fonction membre, end () pour le vecteur. Cela renvoie un itérateur qui pointe juste après le dernier élément du vecteur. L'itérateur retourné par fin () est très compatible avec l'itérateur renvoyé par début (). En fait, ils sont du même type, itérateur.

Dans les parenthèses, l'État débutant est:

iter = iter;

Le moyen que l'opérande gauche, iter, devrait commencer le balayage d'où l'opérande droit, iter pointe vers.

Cette boucle pour les itérateurs peut être résumée comme suit: Lisez chaque élément du vecteur commençant par iter indiqué; Et tandis que la fin du vecteur n'est pas encore atteinte, incrémentez l'itérateur, iter, pour pointer vers l'élément suivant afin de lire l'élément suivant.

Le corps de la boucle est:

char ch = * iter;
couter << ch << ";

L'astérisque dans cette position, est un opérateur d'indirection. Il obtient la valeur indiquée par l'itérateur

Boucler vers l'avant et sauter avec itérateur

Dans la boucle ci-dessus, le prochain argument est, iter++. C'est la même chose que:

iter = iter + 1

Plus-un avec l'itérateur, signifie indiquer l'élément suivant. Cela ne signifie pas, ajoutez l'entier 1, à l'itérateur. Avec cela, les éléments sont lus l'un après l'autre dans la direction avant. Afin de lire tous les autres éléments (sautant un élément à chaque fois), l'argument suivant doit être

iter = iter + 2; qui est le même que iter + = 2;

Le code suivant lit tous les autres personnages:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
vecteur:: iterator iter = vtr.commencer();
pour (iter = iter; iterchar ch = * iter;
couter << ch << ";

couter << endl;

La sortie est:

sautant «B» et «D».

Boucle en arrière

Le code suivant utilise une boucle pour boucler vers l'arrière, un vecteur de caractères (chars), en utilisant les itérateurs:

int main()

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
vecteur:: reverse_iterator iter = vtr.rbegin ();
pour (iter = iter; iterchar ch = * iter;
couter << ch << ";

couter << endl;
retour 0;

La sortie est:

E d c b a

Le revers_iterator a été utilisé ici. Le vecteur a une fonction membre correspondante, rbegin (), qui renvoie un itérateur qui pointe vers le dernier élément du vecteur. Il y a une autre fonction membre, Rend (), qui renvoie un itérateur qui pointe juste avant le premier élément du vecteur.

Pour boucler en arrière, la déclaration précédente entre parenthèses est toujours ironique, «iter ++». Et la condition de ce qui est ironiquement, ironiquement '<'.

Boucle en arrière et sauter

Dans la boucle ci-dessus, la déclaration précédente est, iter++. C'est la même chose que

iter = iter + 1

Avec cela, les éléments sont lus l'un après l'autre dans le sens inverse. Afin de lire chaque élément de commande (sautant un élément à chaque fois) vers l'arrière, l'instruction précédente doit être

iter = iter + 2; qui est le même que iter + = 2;

Le code suivant lit tous les autres personnages à l'envers:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
vecteur:: reverse_iterator iter = vtr.rbegin ();
pour (iter = iter; iterchar ch = * iter;
couter << ch << ";

couter << endl;

La sortie est:

E c a

sautant 'd' et 'b'.

Boucle en utilisant la gamme basée sur la mise en place

La gamme basée sur la gamme est une déclaration plus pratique à utiliser pour parcourir une liste, comme un vecteur. Il n'est pas vraiment utilisé pour sauter ou faire boucle. La syntaxe est:

Pour (Initial-Statement-Optional For Range Declaration: For-Range-Initializer)

Cette fois, il y a deux déclarations entre parenthèses et non trois. La première instruction est la déclaration d'une variable qui contient l'élément suivant dans le vecteur. Cette variable doit être du même type que le type d'éléments vectoriels. Le deuxième argument après le côlon est le nom du vecteur.

Le code suivant montre comment il peut être utilisé:

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
pour (char ch: vtr)
couter << ch << ";

couter << endl;

La sortie est:

A b c d e

Boucle en utilisant la fonction for_each ()

La fonction for_each () est utilisée à partir de la bibliothèque d'algorithme incluse. La syntaxe est:

modèle
Fonction Consxpr pour_EACH (Inputiterator First, InputIterator Last, Fonction F);

Le premier argument est un itérateur qui pointe vers le premier élément du vecteur. Le deuxième argument est un itérateur qui pointe juste après le dernier élément du vecteur. Le troisième argument est le nom d'une fonction, dont le corps est ce qui serait dans la boucle classique. Cette fonction a un paramètre, et c'est la déclaration de la variable qui contiendrait la prochaine valeur du vecteur. Il doit être du même type que chaque élément du vecteur. Cette fonction for_each () n'est pas vraiment utilisée pour sauter ou boucler vers l'arrière.

Le programme suivant montre comment utiliser l'appel de fonction for_each () et une définition de fonction associée:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
void func (char ch)
couter << ch << ";

int main()

vecteur vtr = 'a', 'b', 'c', 'd', 'e';
for_each (vtr.begin (), vtr.end (), func);
couter << endl;
retour 0;

La sortie est:

A b c d e

Conclusion

Pour traverser un vecteur, signifie accéder à tous les éléments du vecteur, du début à la fin, ou de la fin au début. Les éléments peuvent être accessibles pour la lecture ou l'écriture (modification de la valeur) ou les deux.

En C ++, le vecteur peut être en boucle, en utilisant la boucle classique, avec l'indice (index) entre crochets; Il peut être bouclé en utilisant la gamme basée sur la mise en place; Il peut également être boucle en utilisant la fonction for_each () incluse dans la bibliothèque d'algorithmes.

c Sharp

Différence entre == opérateur et méthode égale en C #?

La fonction equals () compare la valeur de deux variables ou objets, tandis que l'opérateur '==' com...

Pauline Giraud

c Sharp

Break and Contiver des déclarations en C #

La déclaration de pause peut quitter une boucle tôt, tandis que continuer peut sauter certaines itér...

Ethan Guillot

C programmation C

Livres et guides pour la langue C

Il y a 6 livres et guides utiles pour apprendre la langue C. Suivez cet article pour apprendre en dé...

Nathan Blanc