Que sont les boucles imbriquées en C ++ avec des exemples?
Boucle à faire
Une simple boucle à faire est:
int m = 0;
faire
couter << m << ";
++m;
tandis que (m<5);
Il y a une condition initiale qui ne fait pas vraiment partie de la boucle. Cette condition initiale est «int m = 0;». La boucle commence par le mot réservé, faire et se terminer par un point-virgule, après la condition While, «(M<5)”. The loop means to print out integers, beginning from zero until m is equal to 5. When m is equal to 5, no printing takes place.
Avec la boucle à faire, le bloc est exécuté en premier, avant que la condition ne soit vérifiée. La condition est remplie lorsque m est égal à 5. Avant cela, le bloc est exécuté 5 fois, à partir d'un décompte de 0 à 4. La sortie est donc:
0 1 2 3 4
en boucle
Avec la boucle à faire, le bloc est exécuté à chaque fois avant la vérification de la condition. D'un autre côté, avec la boucle while, la condition est d'abord vérifiée, à chaque fois, avant que le bloc ne soit exécuté. La boucle suivante fait ce que la boucle à faire ci-dessus a fait:
int m = 0;
tandis que (m<5)
couter << m << ";
++m;
Il y a une condition initiale qui ne fait pas vraiment partie de la boucle. Cette condition initiale est «int m = 0;». La boucle commence par le mot réservé et se termine au second et fermer l'attelle pour son bloc. Il n'y a pas de mot «do» réservé ici. La condition tandis est «(m<5)”, same as in the above code. When the while-condition is false, that is, m equals 5, the block is not executed, and that is the end of the loop. Note that the loop does not end with a semicolon in this case. The output is the same as in the previous code, that is:
0 1 2 3 4
boucle
Dans ce qui précède pendant la boucle, il y a cinq composants principaux. Le premier est l'instruction d'initialisation,
int m = 0;
La répétition de l'exécution du bloc de boucle a lieu pour 5 numéros, commençant quand m est nul. Le composant suivant est la condition while (m<5). No repetition (no execution of the block) occurs when the while condition results in false. The third component is the loop compound statement itself, which can be imagined as the block. The fourth component is inside the loop compound statement. It is:
couter << m << ";
Il imprime la valeur de m. Et le cinquième composant est l'instruction Incrément,
++m;
Qui est dans le bloc, à la fin. Cela provoque la répétition de l'exécution du bloc. Il introduit le numéro suivant pour une exécution répétée du bloc. Cependant, la répétition n'aura pas lieu si la condition de tangage se traduit par une fausse.
Les cinq composants différents peuvent être réorganisés dans une boucle pour: suit:
pour (int m = 0; m<5; ++m)
couter << m << ";
La sortie est la même, je.e.
0 1 2 3 4
Il y a trois déclarations dans les parenthèses de la boucle pour: il y a l'instruction d'initialisation, il y a la condition While, qui est une brève déclaration, et il y a l'instruction Incrément. Dans le bloc, cette fois, il n'y a qu'une seule déclaration, qui est la déclaration de base. La déclaration d'incrément, qui était dans le bloc, a été prise dans les parenthèses. Plus de déclarations peuvent être ajoutées à l'un des blocs ci-dessus.
La boucle à faire et la boucle while est fondamentalement la même que la boucle pour. La boucle forte en boucle sous une forme classique et simplifiée. Toute boucle a besoin d'un état d'initialisation, d'une condition de temps et d'un code pour provoquer la répétition suivante, qui ne se produira pas lorsque la condition While entraînera une fausse.
Lors de la nidification d'une boucle, ces trois fonctionnalités doivent être prises en considération. Cet article explique différentes façons de nicher les boucles en C++. Les formulaires de boucle de base ont été expliqués ci-dessus.
Contenu de l'article
- Boucles à faire à faire
- Nidification de boucles
- Nidification pour les boucles
- Conclusion
Boucles à faire à faire
À partir du programme suivant, une table de 5 lignes et 4 colonnes de caractères est affichée. En C ++, la séquence de lettres majuscules ou la séquence de lettres minuscules peut être comparée car les nombres entiers sont comparés, comme illustré dans la boucle imbriquée suivante:
#inclure
Utilisation de Namespace Std;
int main()
int i = 0;
char j = 'a';
faire
faire
couter << j << ";
j ++;
tandis que (J < 'E');
j = 'a';
couter << endl;
i ++;
alors que je < 5);
retour 0;
La sortie est:
A B C D
A B C D
A B C D
A B C D
A B C D
La première ligne du programme comprend la bibliothèque iOStream dans le programme. Cette bibliothèque est nécessaire pour imprimer le texte. La ligne suivante est une instruction, garantissant que tout nom utilisé provient de l'espace de noms standard, sauf indication contraire.
Il est utile de penser à une boucle imbriquée en deux dimensions. Les deux boucles agissent sur chaque cellule. La boucle intérieure est responsable des colonnes, tandis que la boucle extérieure est responsable des lignes.
Il se passe comme ceci: alors que la boucle externe pointe vers la première ligne, la boucle intérieure imprime une valeur cellulaire, par colonne, pour la première ligne. Alors que la boucle extérieure pointe vers la deuxième ligne, la boucle intérieure imprime une valeur de cellule, par colonne, pour la deuxième ligne. Cela continue jusqu'à l'imprimé de la dernière ligne.
Dans le programme ci-dessus, l'état d'initialisation de la boucle extérieure est,
int i = 0;
L'état d'initialisation de la boucle intérieure est,
char j = 'a';
Notez que toute la boucle intérieure a été placée juste après l'attelle d'ouverture de la boucle extérieure. Une seule déclaration imprime chaque personnage, et cette déclaration doit être dans la boucle intérieure. C'est parce que les boucles accèdent à une cellule par itération combinée. La déclaration est:
couter << j << ";
L'alphabet majuscule peut être manipulé comme des nombres entiers (entiers positifs).
La condition tanguelle pour la boucle intérieure est,
tandis que (J < 'E')
À la fin du noyau de la boucle intérieure, mais pas à la fin du code de boucle intérieure. Cela signifie que la cinquième lettre «e» et au-delà ne doit pas être affichée. Une fois que la boucle intérieure a affiché 4 éléments d'affilée, l'état initial est réinitialisé ou réinitialisé avec l'énoncé,
j = 'a';
qui n'est pas précédé par le mot réservé, char. Le précédant du mot réservé, Char déclarera une nouvelle variable, qui ne fera pas partie de l'itération bidimensionnelle. La déclaration après ça, je.e.
couter << endl;
Forces le curseur de l'écran à la ligne suivante afin que la ligne suivante puisse être imprimée sur la ligne suivante.
Après cette déclaration, le code essentiel pour la boucle extérieure commence. La condition thire pour la boucle extérieure est,
(je < 5)
ce qui signifie que les lignes sont comptées comme 0, 1, 2, 3, 4, encore cinq nombres.
Le code de la boucle intérieure, pour provoquer l'impression du caractère suivant (répétition de la colonne) dans la même ligne, est:
j ++;
Lorsque la condition While pour la boucle intérieure se traduit par une fausse, aucun autre caractère n'est imprimé. Le code pour la boucle extérieure pour provoquer l'impression de la ligne suivante (répétition de ligne) est:
i ++;
Lorsque la condition While pour la boucle extérieure se traduit par une fausse, aucune autre ligne n'est imprimée.
Et donc, la variable, j'ai été utilisée pour la boucle extérieure, les lignes; Et la variable, J a été utilisée pour la boucle intérieure, les caractères de ligne.
Nidification de boucles
Le programme suivant fait la même chose que le programme ci-dessus:
#inclure
Utilisation de Namespace Std;
int main()
int i = 0;
char j = 'a';
alors que je < 5)
tandis que (J < 'E')
couter << j << ";
j ++;
;
j = 'a';
couter << endl;
i ++;
;
retour 0;
La sortie est:
A B C D
A B C D
A B C D
A B C D
A B C D
L'algorithme de ce code est presque le même que celui de la précédente. La principale différence est que, ici, pour chaque itération pour la boucle intérieure ou extérieure, la condition thire est vérifiée avant que le corps de la boucle ne soit exécuté. Dans le code précédent, le corps est exécuté avant la vérification de la condition.
Nidification pour les boucles
Le programme suivant fait la même chose que le programme ci-dessus:
#inclure
Utilisation de Namespace Std;
int main()
pour (int i = 0; i < 5; i++)
pour (char j = 'a'; j < 'E'; j++)
couter << j << ";
couter << endl;
retour 0;
La sortie est:
A B C D
A B C D
A B C D
A B C D
A B C D
Il y a certaines choses à noter ici: la boucle imbriquée est plus courte que leurs autres homologues. L'incréation de la boucle intérieure a été retirée de son corps et emmenée entre parenthèses pour sa boucle. L'incréation de la boucle extérieure a été retirée de son corps et prise entre parenthèses pour sa boucle. La réinitialisation (réinitialisation) de la variable de boucle intérieure, J n'est plus nécessaire comme instruction pour la boucle extérieure; Parce que l'instruction d'initialisation de la boucle intérieure se réinitialise pour chaque itération de la boucle extérieure.
N'oubliez pas que la boucle forte est une forme classique et simplifiée des deux autres boucles.
Conclusion
Une boucle a trois caractéristiques importantes: un état d'initialisation, la condition while et la poussée pour la prochaine répétition du corps de la boucle. Lorsqu'une boucle est imbriquée dans une autre, ces trois caractéristiques doivent être prises en compte pour chacune des boucles correspondantes. Toutes les boucles à nerfs ci-dessus sont des boucles de nidification à un niveau. Il est utile de penser à une nidification à un niveau, de boucles, comme une disposition bidimensionnelle. Le code de la boucle imbriquée est ce qui accède à chaque cellule pour la disposition 2D. Ce tutoriel a donné au lecteur les bases de la nidification de la boucle.