Bonjour et bienvenue. Dans cette conférence, je veux parler des boucles imbriquées et du contrôle de boucle.
Boucles imbriquées, boucles à l'intérieur de boucles, le contrôle de boucle a à voir avec
le break et les instructions continues.
Des boucles donc imbriquées.
Il y a des moments où vous souhaitez placer une boucle à l'intérieur d'une autre boucle.
C'est parfaitement logique.
Ainsi, par exemple, vous
voudrez peut-être compter le nombre d'occupants dans chaque maison sur une rue.
Donc, ce que vous feriez, c'est que vous auriez une boucle extérieure où vous passez de maison en maison.
Et puis chaque maison dans laquelle vous vous trouvez, vous comptez le nombre d'occupants.
J'espère donc que vous pourrez visualiser ou comprendre comment cela pourrait être une boucle imbriquée.
Encore une fois, la boucle extérieure pour traverser toutes les maisons.
Et puis pour chaque itération de la boucle extérieure de chaque maison que vous rencontrez, vous iriez à l'intérieur
de la maison et auriez une boucle pour compter toutes les personnes.
C'est donc un petit cas d'utilisation lorsque vous voulez réellement
utiliser une boucle imbriquée dans c.
Voici un exemple. On dirait que vous pensez que
cela ressemblerait à une boucle à l'intérieur d'une boucle vraiment pas trop compliquée.
Dans cet exemple, nous utilisons des boucles for pour.
Les boucles sont agréables car nous pouvons initialiser la variable de contrôle de
boucle, avoir notre vérification de condition et notre variable de contrôle de boucle de modification sur une seule ligne.
Donc, cette boucle extérieure et appelez-la la boucle intérieure extérieure.
La boucle extérieure est exactement ce qu'elle implique. C'est la boucle à l'extérieur.
Et vous pouvez avoir de très nombreuses couches de nidification différentes. Vous pourriez avoir de nombreuses
boucles internes.
Dans ce cas, nous passons à travers et c'est
une boucle contre-contrôlée, nous commençons à un et nous allons tout le chemin pour compter.
Nous ne savons pas quel compte il y a ici, cela n'a pas d'importance.
Dans le corps de la boucle for, nous disons que la somme est égale à 0. Nous initialisons la somme pour la boucle interne.
Et puis à l'intérieur de la boucle interne, nous voyons une autre boucle for for et j est égal à 1,
j est inférieur à égal à I et plus plus j. On dit alors somme plus égale j.
Nous calculons la somme des nombres entiers de 1 à I.
Donc, ce que cela fait en fait, c'est que vous entrez un chiffre 5.
Et pour la première itération de la boucle,
vous additionnez 1 2 3 4 et 5.
Pour la prochaine itération de
la boucle, vous additionnez 2 3 4 5.
Pour la troisième itération de la boucle, vous additionnez 3 4 5 et ainsi de suite.
Les boucles internes sont donc nécessaires, en particulier en fonction du cas d'utilisation, juste une
boucle à l'intérieur d'une boucle parfaitement.
Vous allez le voir un peu.
N'ayez pas peur. En fonction de ce que vous devez faire et du problème que vous
essayez de résoudre, il est souvent très utilisé.
Et à ce stade, ce n'est pas toujours une boucle for à l'intérieur d'une boucle for, vous pouvez avoir
une boucle while à l'intérieur d'une boucle for. Vous pourriez avoir une boucle do while à l'intérieur d'une boucle
for, cela n'a pas d'importance.
Donc, dans cet
exemple, même exemple exact sauf maintenant dans le corps de la boucle for,
nous avons une boucle imbriquée une boucle interne appelée à l'aide du mot-clé while.
Nous sommes donc toujours en train de calculer certains des nombres entiers de 1 à I.
Nous avons une initialisation en dehors de la boucle while.
Nous avons une condition à l'intérieur du contrôle while,
et nous avons nos sommes dans le corps de la boucle while
où nous sommes modifiés, c'est la variable de contrôle de boucle que nous modifions.
Donc somme plus est égal, puis nous modifions la variable de contrôle de boucle avec plus plus j.
Donc, si nous ne modifions pas plus plus j, nous aurions une boucle infinie pour la boucle while.
Mais il fait la même sortie, il utilise simplement une boucle while comme boucle imbriquée au lieu de la boucle for.
Donc, la nidification n'est pas vraiment différente de celle où vous nidifiez quoi que ce soit.
Vous avez imbriqué des instructions if, des instructions if à l'intérieur des instructions if, des
instructions de boucle imbriquées en boucle à l'intérieur de boucles.
Pour sortir du concept
de boucles imbriquées, parlons de l'instruction continue.
Jusqu'à ce stade, lorsque nous avons parlé de boucles, nous
avons toujours exécuté la boucle un certain nombre de fois en fonction de la condition
de sortie, l'expression booléenne qui prend la valeur false.
Cependant, il y a des moments où vous souhaitez spécifiquement terminer une boucle plus tôt
ou que vous souhaitez continuer sur l'itération suivante
de la boucle sans rien faire.
Dans ce dernier cas, en continuant sans rien
faire, en sautant essentiellement, vous
pouvez utiliser l'instruction continue pour ce faire.
Ainsi, l'instruction continue dans le corps d'une boucle effectue les opérations suivantes.
Et tout d'abord, si vous voulez initier cela, il vous suffit de mettre le mot-clé
continue suivi d'un point-virgule dans le corps de la boucle.
Mais ce qu'il va faire, c'est
ignorer cette itération. Donc, tout ce qui suit en
dessous du continue ne sera pas exécuté s'il se trouve dans le corps de la boucle.
Alors continuez souvent, nous voudrons être au sommet de la boucle en
fonction d'une condition, elle est généralement enveloppée dans une instruction if.
Si cela se produit dans une situation particulière, je ne veux
exécuter aucun code dans le corps de la
boucle, sautez simplement cette itération et vérifiez la prochaine fois.
Et encore une fois, c'est un peu déroutant parce que vous sautez une itération et que vous sautez,
mais c'est valide, et c'est un moyen de faire plusieurs vérifications.
Ainsi, même si vous avez votre condition de sortie de boucle dans votre expression booléenne,
vous pouvez avoir une autre vérification.
Et cette vérification ne sortira pas de la boucle, mais
elle sautera une itération.
Il est donc à nouveau utilisé pour le cas où vous souhaitez ignorer l'itération. L'avantage est que vous pouvez
continuer à utiliser et cela éliminera beaucoup d'imbrication.
Cela éliminera également beaucoup d'instructions if supplémentaires à l'intérieur de votre bloc de boucles.
Cela peut donc améliorer la lisibilité lorsque
les instructions sont très longues ou que vous avez une imbrication profonde.
Donc, si vous trouvez que vous faites beaucoup de nidification.
vous voudrez peut-être dire que je peux peut-être utiliser un continue à la place.
Ou si vous trouvez que vous avez beaucoup d'instructions
if qui font certaines choses à l'intérieur du corps de la boucle, vous voudrez peut-être continuer.
N'utilisez pas le continue si cela complique plutôt que simplifie le code.
N'utilisez pas le continue si vous ne savez pas ce que vous faites.
Voici un exemple de la suite.
Dans cet exemple, nous créons une nouvelle énumération de type day,
et nous disons que les valeurs valides sont lundi mardi mercredi jeudi vendredi samedi dimanche.
Et puis nous avons une boucle for où nous initialisons notre énumération
à lundi, et nous disons que tant
que le jour est inférieur à celui du dimanche, c'est
une condition pour sortir, puis nous disons plus plus jour.
Vous pouvez vous poser la question de savoir comment incrémenter une énumération?
Eh bien, rappelez-vous qu'une énumération sous le capot est un entier.
Vous pouvez donc dire plus plus jour sur une énumération et cela va simplement l'incrémenter au suivant.
Rappelez-vous, lundi est égal à 0, mardi est égal à 1, mercredi
est égal à 2, tout est dans l'ordre de la liste.
Tellement parfait pour incrémenter les énumérations.
Dans cette boucle for si c'est mercredi, nous
voulons sauter. Nous ne voulons rien faire. Nous ne voulons pas imprimer.
Alors nous disons continuer. Si le jour est égal
à mercredi, continuez. Il va sauter la ligne d'impression. Il va remonter en haut
de la boucle, et il va exécuter la prochaine itération.
Et donc ce sera jeudi.
Ce ne sera pas égal à mercredi, donc ça ne va pas sauter.
Il va descendre et imprimer ce n'est pas mercredi.
C'est donc un cas d'utilisation courant, un exemple courant d'utilisation de continue, une syntaxe très facile à utiliser,
juste un simple mot-clé suivi du point-virgule.
L'autre cas où vous voudrez peut-être faire quelque chose de bizarre dans la
boucle est si vous voulez quitter tôt.
Donc, normalement, après que le corps de la boucle
a été entré, un programme exécutera toutes les instructions dans le corps de
la boucle et pour chaque itération, puis il vérifiera et sautera.
Et nous savons comment fonctionne la suite, ce qui fait un saut un peu différent.
Il existe une autre instruction qui peut modifier l'exécution de toutes les instructions de la boucle,
elle s'appelle la rupture.
Et cela devrait être quelque peu familier car nous utilisons le mot-clé break lorsque nous avons parlé
de l'instruction switch.
Souvenez-vous que lorsque nous avions nos cas, nous sortions des affaires de cette façon.
Eh bien, vous pouvez également utiliser le mot-clé break à l'intérieur d'une boucle.
Et ce que cela fera, c'est qu'il sautera juste de la boucle.
Ainsi, l'instruction break va provoquer la sortie immédiate du programme de la boucle, il est en cours d'exécution.
Les instructions de la boucle sont ignorées et l'exécution de la boucle est terminée.
Vous sortez donc de la boucle.
Vous exécutez tôt. Si l'instruction break est à l'intérieur de boucles imbriquées, elle n'affectera
que la boucle la plus interne, la contenant. Vous ne ferez que sauter hors de la boucle dans laquelle vous êtes.
Et pour ce faire, vous utilisez le mot-clé break suivi d'un point-virgule.
La pause est souvent utilisée pour laisser une boucle lorsqu'il y a 2 raisons distinctes de partir.
Donc, plus tôt, j'ai mentionné que vous pouvez avoir une autre raison pour laquelle vous voulez
sauter une itération, mais s'il y a 2 raisons, 2 conditions où vous voulez sauter hors d'une boucle, vous
pouvez utiliser une pause.
Si vous n'avez qu'une
seule condition, alors c'est juste la condition, à l'intérieur de la boucle elle-même, à l'intérieur
des parenthèses du while ou avant le deuxième point-virgule dans la boucle for.
Break est également utilisé dans les instructions switch, comme je l'ai mentionné.
Alors je voulais juste vous le rappeler. Ne les confondez pas.
Cependant, ils font essentiellement les mêmes choses. Ils sautent hors du code.
La rupture d'une instruction switch sautera entièrement de
cette instruction switch, la rupture d'une boucle sautera hors de cette boucle.
Eh bien, voici un exemple. Nous avons une boucle while.
Nous imprimons des entiers.
Nous lisons quelques nombres entiers. Nous avons une boucle while imbriquée.
À l'intérieur de la boucle while imbriquée, nous vérifions
ce qui a été entré. Et s'il est supérieur à
100, nous voulons sortir de cette boucle interne. Alors nous faisons.
Ensuite, dans la boucle extérieure, nous devons faire une autre vérification. S'il est supérieur à 100, nous sortons
de cette boucle externe.
Si vous n'aviez pas la deuxième pause, vous ne sauteriez jamais hors de la deuxième boucle extérieure.
Donc, dans ce cas, cela me rappelle un endroit où vous pourriez utiliser un aller.
Imaginez si vous aviez 5 emboîtements, 5 couches d'imbrication, tandis qu'une boucle à l'intérieur d'une boucle while à
l'intérieur d'une boucle while à l'intérieur d'une boucle while à l'intérieur de la boucle while.
Si vous utilisiez simplement le break pour essayer de sauter
hors des boucles, vous auriez toutes ces instructions if dans chaque boucle pour sauter.
Au lieu de faire toutes ces déclarations
if, vous pourriez aller à. Le go to sauterait de toutes les boucles d'état de la boucle en une seule commande.
C'est donc un cas d'utilisation pour une visite. Mais dans ce cas, nous ne faisons
que montrer des pauses et nous assurons que vous comprenez que vous venez
de sortir de cette boucle dans laquelle vous êtes.
Et dans ce cas, nous sortons de 2 boucles.
Voici donc les 2 exemples, les 2 mots-clés où vous ne pouvez essentiellement pas répéter le code de
ce à quoi vous vous attendez.
Donc, si jamais vous voyez une interruption ou continuez dans la boucle,
assurez-vous de comprendre ce qui se passe
car vous n'exécutez peut-être pas certains codes qui, selon vous, vont être exécutés.
Encore une fois, généralement enveloppé à l'intérieur d'une condition if. Vous pouvez donc voir les
choses de cette façon, mais vous voulez également fournir de bons commentaires lorsque vous utilisez pause ou continue.
J'espère que cela t'aides. Dans la prochaine conférence, nous allons
relever un défi où nous allons être en mesure d'utiliser
ces boucles et cela vous démontrera et vous aidera à tout savoir sur les boucles while for et à interrompre
et à continuer. Merci.