Bonjour et bienvenue à nouveau.
Je vais encore parler un peu du flux de contrôle.
Alors plongons directement dans les boucles répétant le code.
Tout d'abord, nous allons en parler pour la boucle.
La boucle for va être entièrement
consacrée à la répétition du code. Donc, juste pour rappel, la répétition
du code est un moyen de ne
pas dupliquer et vous exécutez peut-être plus d'un code similaire à la
fois.
Ainsi, le langage de programmation c a certaines constructions conçues pour le
langage que vous pouvez utiliser lorsque vous souhaitez répéter du code.
Et cela vous permet de répéter un bloc d'instructions jusqu'à ce qu'une condition soit remplie.
C'est donc similaire à la boucle for et que vous allez évaluer une
expression booléenne, une condition. Vous ne pouvez pas courir éternellement.
Lorsque vous exécutez une boucle pour toujours, cela signifie que c'est une boucle infinie.
Et il y a seulement certains moments où
vous voudrez peut-être le refaire généralement pour surveiller ou écouter quelque chose.
Ainsi, le nombre de fois qu'une boucle est répétée peut être contrôlé simplement par compte.
Il existe 2 types de boucles que
vous pouvez faire, une boucle de contrôle de compteur ou comme une boucle de contrôle sentinelle, c'est ce qu'ils appellent.
Une boucle de contrôle de compteur signifie que
la boucle s'exécute 10 fois, 20 fois, 30 fois, une durée spécifique.
Il répète plusieurs fois le même bloc d'instructions dans
la boucle.
Vous pouvez avoir un autre type de boucle sans contrôle de compteur.
Il peut fonctionner 5 fois, il peut exécuter un 100, il peut en
vouloir 20, tout dépend d'une condition, d'une variable ou quelque chose. Ainsi, par exemple, vous pouvez exécuter une boucle qui dit
que je vais exécuter ma boucle encore et encore et encore jusqu'à ce que
l'utilisateur entre pour quitter.
Donc, jusqu'à ce que la variable change pour quitter. Ce n'est pas contre-contrôlé. Ce n'est pas dépendant.
Encore une fois, il peut fonctionner 10 fois, il peut s'exécuter 100 fois.
Ce sont les 2 types de boucles différents. Je vais donc donner des exemples des
deux, mais pensez-y simplement à un niveau élevé quand est-ce que je voudrais répéter le code?
Eh bien, je peux vouloir répéter le code 5 fois, un certain laps de
temps, un laps de temps définitif ou je peux vouloir
mettre du code en fonction d'une certaine condition entrée par un utilisateur, et cela s'appelle sentinel.
Notre boucle for a le mot-clé for. Il est utilisé pour exécuter un
certain nombre de fois. Il est généralement utilisé pour le contrôle de compteur, mais ce n'est pas nécessaire.
Vous pouvez l'utiliser pour une boucle de contrôle de compteur ou une sentinelle pour contrôler la boucle.
C'est à vous. Mais beaucoup d'exemples dans beaucoup de
pratiques sont contre-contrôlés, un certain nombre de fois.
Si vous souhaitez afficher les nombres de 1 à 10, par exemple, vous utiliserez la boucle for.
Vous ne voudriez pas écrire 10 lignes de code
avec la même instruction printf en affichant un nombre différent.
C'est très inefficace. Cela prend beaucoup de temps.
Vous utiliseriez une boucle for pour répéter le code.
Ce que vous feriez, c'est que vous feriez quelque chose comme ça.
Voici une introduction à ce à quoi ressemble la
boucle for, la syntaxe.
Vous avez le mot-clé for, puis vous avez ces parenthèses.
Encore une fois, les parenthèses identifient différentes choses qui se passent pour
la boucle for.
Ensuite, vous avez une parenthèse et des instructions entre crochets.
Encore une fois, les crochets représentent le corps de la
boucle, tout comme les crochets représentant le corps d'une instruction if.
Si vous n'avez qu'une seule instruction, vous n'avez pas besoin des crochets, mais il
est recommandé de toujours les utiliser.
Donc, dans cet exemple ici, vous voyez le mot clé for, qui devrait être la première chose que vous identifiez.
L'opération, la durée de son exécution est contrôlée et ce qui apparaît entre les parenthèses
après le mot-clé for, que nous allons entrer dans les détails.
Il y a fondamentalement 3 expressions différentes à l'intérieur.
Et vous pouvez les reconnaître car ils sont séparés par le point-virgule.
Donc, le point-virgule indique que c'est une déclaration d'expression.
Alors, que font ces 3 choses, nous allons les décrire.
L'action que vous voulez répéter se
trouve à l'intérieur du corps de la boucle, c'est ce qui arrive tant de fois.
Dans cet exemple, le corps de la boucle est printf.
Donc, si une condition est évaluée comme vraie, elle continuera à imprimer ce nombre.
Et encore une fois, pour les instructions simples, vous pouvez omettre les accolades.
Alors passons en revue cela en détail.
le modèle général de la boucle for est que vous avez ce type d'instruction.
Vous avez un for et ensuite vous avez une condition de départ, c'est un pseudocode.
J'essaye de décrire la boucle for ici.
La condition de départ est donc la première chose, tout avant le premier point-virgule.
La deuxième chose est la condition de continuation avec
un point-virgule à la fin, puis la dernière chose entre les parenthèses est l'action par itération.
Et je veux décrire chacun de ces éléments. Et puis après cela, à l'intérieur du corps se trouve la déclaration de boucle.
La déclaration de boucle est assez simple. C'est juste à l'intérieur du corps.
C'est le code qui va être exécuté qui se répète à chaque fois.
C'est assez basique.
Et encore une fois, vous pouvez soit casser les accolades si vous avez plusieurs instructions, soit omettre
les accolades si vous avez une seule instruction.
La condition de départ, cette première chose entre
parenthèses avant le premier point-virgule est généralement, mais pas toujours,
elle initialise généralement une variable, appelée variable de contrôle de boucle.
C'est la variable que vous allez commencer à examiner à chaque itération.
Donc, la variable de contrôle de boucle est généralement un compteur
de quelque temps, pas toujours, je tiens à souligner que
ce n'est pas nécessaire. Mais souvent, dans une boucle for, c'est
un compteur, et il enregistre la fréquence à laquelle la boucle a été répétée.
C'est ce que font cette condition de départ et la variable de contrôle de boucle.
Vous pouvez également déclarer et initialiser plusieurs variables du même type ici avec
la déclaration séparée par des virgules. Vous pouvez donc avoir plusieurs initialisations ici
variables.
Maintenant, selon le compilateur c que vous utilisez,
vous ne pourrez peut-être pas déclarer ces variables dans l'instruction for.
Si vous utilisez quelque chose en dessous du compilateur C99, vous devez
déclarer les variables en dehors de l'instruction for, puis vous les initialiserez simplement là où la condition
de départ le dit, mais
nous passerons en revue certains de ces exemples.
Mais la condition de départ est celle où vous initialisez les variables.
C'est la variable de contrôle de boucle et elle est nommée pour cette raison car elle
contrôle la fréquence à laquelle la boucle va s'exécuter lorsque vous l'initialisez.
La prochaine chose dont je veux parler est la condition continue, la condition de continuation,
la partie qui précède le premier point-virgule dans la boucle for.
Ceci est une expression logique.
C'est la condition qui va être évaluée comme vraie ou fausse.
C'est à ce moment que vous allez sauter dans la boucle ou sortir de la boucle.
Cela détermine si la boucle doit continuer à être exécutée.
Tant que cette condition a la valeur true, la boucle continue à
s'exécuter, toutes les instructions du corps vont être exécutées.
Cela vérifie généralement la valeur de la variable de contrôle de boucle.
Vous initialisez donc la variable de contrôle de boucle dans la condition de départ,
puis vous la regardez dans la condition de continuation.
Vous pouvez mettre n'importe quelle logique ou n'importe quelle expression arithmétique ici tant que vous savez ce que vous faites.
La condition de continuation est testée au début de la boucle plutôt qu'à la fin.
C'est ce qu'on appelle une boucle de pré-test.
Vous remarquerez la différence lorsque nous parlons de la boucle do-while, qui est une boucle post-test.
Mais cela signifie que l'instruction de boucle peut être exécutée une fois, elle
peut être exécutée 0 fois.
Tout dépend du fait que la condition de continuation est évaluée comme vraie ou fausse.
S'il est évalué à faux, vous n'allez jamais exécuter le corps.
Si la valeur est true, vous exécuterez ce corps au moins une fois.
L'action par itération qui se trouve à la toute fin de la boucle for après le deuxième point-virgule,
qui effectue généralement une sorte de modification de la variable de contrôle de la boucle.
Il l'incrémentera ou le décrémentera s'il s'agit d'un
compteur de boucle ou s'il s'agit d'une boucle sentinelle, il peut demander à l'utilisateur d'entrer plus d'entrée.
Vous pouvez également effectuer plusieurs modifications d'une variable.
Vous pouvez modifier la variable de contrôle de boucle et vous pouvez modifier d'autres variables.
Il vous suffit de les séparer par des virgules.
Mais pour résumer tout ce
que j'ai dit, nous avons ce petit tableau qui décrit cela.
Mais avant d'en parler, regardons un petit exemple.
Voici donc un exemple. Nous avons le mot-clé for.
Et puis vous remarquerez que nous avons int I égal 1 j égal
2, c'est là que nous initialisons les variables.
Et nous initialisons en fait 2 variables ici séparées par une virgule,
généralement dans une boucle for, en initialisez simplement une, la variable de contrôle de boucle.
Mais dans ce cas, nous initialisons I et j.
Et puis après ce point-virgule, nous avons la condition.
Quand allons-nous entrer et chaque fois que nous allons quitter cette boucle.
Nous allons entrer tant que I est inférieur à 5.
C'est notre expression booléenne évaluée à vrai ou faux.
Et puis après ce deuxième point-virgule, nous
allons modifier cette variable de contrôle de boucle ou toute autre variable qui nous concerne.
Ici, nous faisons un plus, plus I, c'est
un opérateur d'incrémentation, préfixe I. Et puis nous assignons j égal à j plus 2.
Ce sera généralement votre condition x, modifiant cette variable
de contrôle de boucle.
Et puis le corps de la boucle n'a qu'une seule instruction, nous n'avons donc pas besoin des crochets.
Nous imprimons simplement les valeurs de I fois j.
Ainsi, la sortie produite par ce code
sera les valeurs 2, 8, 18, 32 et 50 sur une seule ligne.
La première itération de la boucle, I va être égal à 1, j va être égal à 2.
Et donc ça va dire I fois j, qui est 1 fois 2 et ça va l'afficher.
Il va vérifier que je ne suis pas supérieur à 5, je ne suis pas à 1.
Il va donc remonter et s'exécuter une deuxième fois.
Et nous modifions également cette variable I dans notre dernière déclaration.
Donc, dans la deuxième itération de la boucle, je vais être égal à 2.
Et j va être égal à 2 plus 2 qui vaut 4.
Alors maintenant, nous allons multiplier 2 fois 4, ce qui fait
8 et nous allons l'afficher et ensuite nous allons vérifier si
je suis supérieur à 5? Non, j'ai encore 2 ans.
Nous modifions donc I pour qu'il soit maintenant égal à 3 pour
la prochaine itération, et nous modifions j pour être égal à 4 plus
2 qui vaut 6.
Et puis pour la troisième itération
de la boucle, on multiplie I fois J. On dit donc 3 fois 6 et on affiche 18.
Avant d'exécuter la quatrième itération, nous vérifions si I est supérieur à 5.
Non, c'est 4. Ensuite, on l'incrémente, on dit que c'est 5. C'est égal à 5, donc il fonctionnera toujours.
Ensuite, nous en ferons 32, puis nous en ferons 50.
C'est donc une déclaration for. Vous voulez l'exécuter et l'exécuter dans le
navigateur de code et jouer et changer les choses.
Mais ce que nous faisons ici, c'est que nous faisons 3 choses distinctes sur une seule ligne de code.
Nous initialisons la variable de contrôle de boucle ou toute autre variable.
Nous avons notre expression booléenne après notre premier point-virgule, notre condition de sortie.
Et puis nous modifions la variable de contrôle de boucle et toutes les autres variables que
nous voulons comme dernière partie de l'instruction for.
Donc, pour résumer ce que nous faisons, j'ai trouvé ce joli petit tableau pratique
tiré d'un livre et je voulais vous le montrer. Cela résume tout.
Ce premier point-virgule initialise la variable de contrôle de boucle.
Après le premier point-virgule, nous faisons notre condition, notre expression booléenne.
Et puis après le deuxième point-virgule,
nous modifions cette variable de contrôle de boucle. Et c'est l'exemple typique que vous voyez.
Il s'agit d'une boucle de contrôle de compteur qui commence à 1 et va jusqu'à 10.
Cela va donc s'exécuter 10 fois.
La clé y étant inférieure à égale à 10. Vous allez donc voir les opérateurs relationnels comme nos conditions,
tout comme nous avons vu les opérateurs relationnels comme nos conditions sur notre instruction if.
La clé ici est que vous souhaitez modifier cette variable de contrôle de boucle ou vous n'allez jamais quitter.
Donc, le compte plus plus est très important.
Et en ce qui concerne la pré ou post incrémentation, que ce plus plus soit avant la variable
ou après la
variable, vous n'avez pas à vous en soucier
car il ne sera incrémenté ou décrémenté qu'après l'itération de la boucle, donc il ne le fait pas.
Peu importe si vous faites plus plus comptez ou comptez plus plus.
Et aussi, selon la version de c que vous exécutez pour
votre compilateur, vous pourrez peut-être
déclarer la variable count dans la boucle for ou vous devrez peut-être dire int
count est égal à 1 ou in count en dehors de la boucle for et puis initialisez-le dans le premier point-virgule.
C99 a ajouté l'initialisation et la déclaration dans la même
partie de la boucle for.
Mais c'est essentiellement ainsi que fonctionne la boucle for.
Passons maintenant à un petit exemple, je veux vous montrer la flexibilité de la boucle for.
Voici un exemple où nous allons simplement additionner quelques entiers.
Et dans cet exemple, nous allons demander à l'utilisateur de saisir un nombre d'entiers qu'il souhaite additionner.
Nous allons stocker cela dans une variable appelée count.
Nous allons maintenant avoir une boucle for qui parcourt
tous ceux-ci en fonction du nombre qu'ils ont parcouru autant de fois.
Donc, ici, nous disons 4, nous avons un int non signé, n'a pas besoin d'être non signé
pour int I égal à 1. Nous initialisons la variable de contrôle de boucle.
Et puis nous disons que si je suis inférieur à compter, c'est à ce moment-là que nous allons quitter et
ensuite nous allons modifier le matériau de la boucle plus plus moi
Donc, cela va fonctionner. Encore une
fois, le 1 au nombre que l'utilisateur a entré, 10 ou 20.
Et tout ce que nous allons faire, c'est dire que la somme est égale à la somme plus 1.
Maintenant, la boucle for est si puissante car la boucle for vous permet
de modifier de nombreuses variables.
Nous n'avons même pas besoin de mettre cette somme plus égale à I dans le corps de la boucle for.
Nous pouvons le mettre à la fin de la dernière déclaration.
Donc, en plus d'incrémenter I de 1, nous pouvons simplement dire somme plus égale I plus plus.
Nous avons donc tout fait en une seule ligne
de code, et cela vous montre la flexibilité. tout cela parce que nous pouvons
modifier la variable dans l'instruction for elle-même. Nous n'avons pas besoin d'avoir cette ligne de corps.
Jetons donc un coup d'œil à cet exemple dans des blocs de
code pour vous montrer comment vous pouvez le manipuler et voir quelle est la sortie.
Voici notre exemple que nous avons eu dans la conférence. Je veux aller de l'avant et essayer de compiler ceci.
Et quand je compilerai ceci, vous remarquerez que j'ai une erreur.
Il dit que je ne peux pas déclarer ma variable dans mon instruction for. C'est parce que j'exécute une ancienne version
du compilateur c. J'utilise le C89.
Vous n'aurez probablement pas ça.
Mais pour résoudre, si jamais vous voyez ce type d'erreur, il vous suffit de
le décliner en dehors de la boucle for. Alors vous dites juste non signé je
Et puis à l'intérieur de la boucle for, vous
l'initialisez, quelque chose comme ça. Essayons maintenant de construire et
je dois juste me débarrasser de certains de ces spécificateurs de format.
Ainsi, lorsque je compile avec succès et que
j'exécute ce programme, vous allez voir comment la boucle fonctionne.
Il va me demander de saisir les nombres entiers que je veux additionner. Si j'entre 5, ça va
résumer 1 2 3 4 et 5 qui est 15.
Et ce que nous pourrions faire pour déboguer cela, c'est que nous pourrions ajouter un crochet à la boucle
for, et nous pourrions vouloir juste voir combien de fois il s'exécute, nous pouvons ajouter une instruction
print pas nécessairement pour le déboguer, mais simplement voir ce qui se passe , nous pourrions dire à l'intérieur de la boucle.
Et cela nous dira que la boucle s'exécute 5
fois parce qu'elle va courir I pour compter.
Donc ce que je veux montrer, c'est combien de fois cela fonctionne. Alors maintenant, quand je le construis
et que je l'exécute, je vais voir ce qui se passe à chaque itération.
Alors je vais dire 8.
Boucle intérieure, boucle intérieure, boucle intérieure, je n'ai pas ajouté de saut de ligne. C'est donc difficile à lire, mais
la boucle intérieure est affichée 8 fois.
Et puis je résume chacun de ces nombres à l'intérieur de boucles, donc la réponse
est 36, 1 plus 2 plus 3 plus 4 plus 5 plus 6 plus 7 plus 8.
Vous pouvez donc jouer avec ça. Mais encore une fois, nous
initialisons notre variable de contrôle de boucle. Nous vérifions la condition pour sortir. Nous allons quitter une fois que nous avons
touché ce que l'utilisateur a entré. Si l'utilisateur a entré 8, nous
allons exécuter 8 fois et ensuite nous devons modifier I. Si nous ne modifions pas I ici, vous auriez une boucle pour toujours.
Et que se passerait-il lorsque vous exécuteriez le
programme, il fonctionnerait pour toujours.
Ainsi, vous verrez après avoir entré le numéro, votre programme ne se fermera jamais.
Alors disons que nous entrons 6, je clique sur Entrée, regarde ce qui se
passe, j'imprime juste une boucle à l'intérieur. Ça ne sort jamais.
C'est une boucle infinie. Cette dernière chose est donc très, très importante. Vous souhaitez toujours modifier votre variable de contrôle de boucle.
Et encore une fois, la variable de contrôle de boucle détermine la sortie, dans ce cas I.
La boucle for est donc un peu utilisée.
C'est très facile à utiliser et cela vous permet de faire 3 choses différentes à l'intérieur de la boucle.
Initialisez la variable de contrôle de boucle, vérifiez le contrôle
de boucle de la variable pour la condition de sortie, puis modifiez
cette variable de contrôle de boucle.
Ce sont 3 choses que vous devez faire en boucle et que vous pouvez faire en une seule instruction.
Maintenant, permettez-moi de parler très rapidement de la boucle infinie.
Alors je viens de démontrer une boucle infinie. C'est là que vous ne sortez jamais.
Et vous n'avez aucune obligation de mettre des paramètres dans l'instruction de boucle for.
Vous pouvez en fait écrire une boucle infinie exprès.
La façon dont vous feriez cela est de mettre simplement les points-virgules là-dedans.
Vous auriez donc une boucle for avec 2 points-virgules.
Si jamais vous voyez cela, cela signifie que vous écrivez une boucle infinie.
Maintenant, généralement, vous ne voulez pas avoir de boucles
infinies, mais il y a des moments parce que la condition pour continuer la boucle est absente.
La boucle se poursuivra indéfiniment. Ceci est parfois utile si vous surveillez des données.
Donc, si vous surveillez des données, vous pourriez avoir quelque chose là-dedans.
En règle générale, lorsque vous avez une boucle éternelle, vous avez généralement
également un sommeil, ce qui suspendra l'exécution du programme, peut-être pendant une seconde pour que vous surveilliez quelque chose.
L'autre cas d'utilisation où vous pourriez avoir une boucle infinie est si vous êtes à l'écoute d'une connexion.
Donc, si vous attendez et que vous écoutez la connexion ou si vous tirez quelque chose pour
voir quelque chose, vous pouvez le faire.
Maintenant, certaines personnes soutiennent que vous ne devriez jamais tirer et que vous ne devriez
jamais écouter, mais c'est un autre argument.
C'est vraiment le seul cas pour certaines boucles for infinies.
Évitez autant que possible les boucles infinies en modifiant cette variable de contrôle de boucle.
J'espère que cela a été utile. C'est la boucle for.
Nous utiliserons une boucle for dans l'un de nos défis, afin de nous familiariser davantage.
Merci.